Python 基础知识

Python程序

Python交互模式

敲下命令：python3 提示符：>>> 输入exit() 并回车 退出 python交互模式 回到 命令行模式

.py 文件 只能在 命令行模式 python3 hello.py —-> 路径在 Python 中

命令行模式和Python交互模式

Python交互式环境下

输出

>>> print('hello,world','relaxing atmosphere','working atmosphere')
# hello,world relaxing atmosphere working atmosphere
>>> print(100+300)
# 400
>>> print(400)
# 400
>>> print('100 + 300 =',100 + 300)
# 100 + 300 = 400

输入

input() 用户输入 字符串 存放 变量 里 可以直接输入 name 查看变量内容 / print()函数

>>> name = input()
# Smile
>>> name
# 'Smile'
>>> print(name)
# Smile

# hello.py
name = input('please enter your name:')
print('hello,', name)
python3 hello.py
please enter your name: Smile
hello,SmIle

Python基础

数据类型和变量

整数

Python 可处理 任意大小的整数 包括负整数

二进制：前缀 0b/0B 0b1010 ( 十进制10 ) 十六进制： 前缀 0x 和 0-9,a-f 0xa/0XA ( 十进制10 )

Python允许数字中以 _ 分隔 10_000_000_000 = 10000000000 0xa1b2_c3d4 = 0xa1b2c3d4

浮点数

浮点数 也就是 小数 10 用 e 替代 1.23e9 = 1.23*10^9 / 12.3e8 0.000012 = 1.2e-5

整数运算永远是精确的 浮点数运算可能会四舍五入的误差

字符串

字符串 是以 单引号' 或 双引号 " 括起来的任意文本 'abc' (只有a,b,c 3个字符) "where"

"I'm ok" (6个字符) 既包含'又包含 " 用 转义字符 \\ 来标识 ‘I\\‘m\\"OK\\"!' —–> I 'm "OK" !

\\n 表示换行 \\t表示制表符 \\\\ 表示字符就是\\ '''…''' 表示多行内容

布尔值

布尔值 经常用在 条件判断 中

布尔值：True , False

运算：and , or , not

and 与运算 所有都是True 结果为True

or 或运算 其中一个为True 结果为True

not 非运算 单目运算符 True变False False变True

空值

空值： None None 不能理解为 0 0 为有意义的 None 是一个特殊的空值

变量

变量 在程序中用一个 变量名 表示 变量名：大小写英文、数字和_ 组合 不能用数字开头

动态语言 变量本身类型 不固定的语言

a = 123 #a是整数

print(a)

a = 'ABC' #a变为 字符串

print(a)

静态语言 定义变量时 必须指定变量类型 如果赋值类型不匹配 报错

// Java 是静态语言

int a = 123; // a 整数类型变量

a = "ABC"; // 错误：不能把 字符串 赋给 整型变量

a = 'ABC'

Python 解释器：

1. 内存中 创建一个 'ABC' 字符串

2.内存中 创建一个名为 a 的变量 并 指向 'ABC'

常量

常量：不能变的变量 全部大写的变量 常数π MA = 3.141592653589

Python除法

字符串和编码

字符编码

编码出现的底层原因：计算机只能处理数字 文本需转化为数字(编码)才可被处理 不同语言对编码需求不同

ASCII 基础款 基础单子节 仅覆盖英文字符/数字/基础符号(127个) 所有编码基础 无法兼容多语言

Unicode 统一款 统一多语言字符集 解决乱码问题 常用 UCS-16编码(2/4字节 固定长度) 纯英下比ASCII多占1倍空间

UTF-8 实用款 Unicode的“可变长编码”实现 兼容ASCII 英文(1字节) 汉字(3字节) 生僻字符(1-6字节) 兼顾多 语言 和 存储/传输效率

计算机系统编码工作流程

内存中： 统一用Unicode编码 —- 方便多语言处理

存储/传输（硬盘/网络）： 转化为 UTF-8编码 —- 节省空间

记事本编辑、网页浏览遵循“读取UTF-8 –> 转Unicode到内存 –> 编辑后转UTF-8 保存/传输”

Python字符串

Python3 字符串 Unicode编码

ord()函数 获取字符整数表示 chr()函数 把编码转换为对应的字符

print('包含中文的str')
# 包含中文的str
ord('A')
# 65
ord('中')
# 20013
chr(66)
# 'B'
chr(25991)
# '文'

Python字符串类型 str

内存中： Unicode 1字符对应若干个字节

存储/传输（硬盘/网络）： str 变为以 字节 为单位的 bytes

Python 对 bytes 类型数据 用 b 前缀 单引号 或 双引号 表示：

x = b'ABC'

'ABC' b'ABC' 前者是 str 后者 虽然内容和前者一样 但bytes 每个字符都只占用一个字节

Unicode 表示的 str 通过 encode() 可编码为指定的 bytes

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\\xe4\\xb8\\xad\\xe6\\x96\\x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

在bytes中 无法显示为ASCII字符的字节 用 \\x## 显示

网络或硬盘读取字节流 读取到的数据为 bytes bytes—>str 用decode()

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\\xe4\\xb8\\xad\\xe6\\x96\\x87'.decode('utf-8')
'中文'

bytes中 包含 无法解码的字节 decode()方法会报错

>>> b'\\xe4\\xb8\\xad\\xff'.decode('utf-8')
Traceback (most recent call last):
…
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 3: invalid start byte

bytes中 只有一小部分无效的字节 可传入 errors='ignore' 忽略错误的字节

>>> b'\\xe4\\xb8\\xad\\xff'.decode('utf-8', errors='ignore')
'中'

Calculate the number of characters in a str using the len() function

>>> len('ABC')
3
>>> len('中文')
2

计算 bytes 含多少字符 len()函数

>>> len(b'ABC')
3
>>> len(b'\\xe4\\xb8\\xad\\xe6\\x96\\x87')
6
>>> len('中文'.encode('utf-8'))
6

源代码中包含中文时 文件开头写入

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

按照UTF-8编码读取

格式化

% 运算符 格式化字符串

有几个 %? 占位符 后面就跟几个变量或值

format() 格式化字符串

f-string

{r} 被变量 r 值替换 {s : .2f} 被变量 s 值替换

list 和 tuple

list

Python内置 一种 数据类型 列表 list ( 有序集合 随时 添加 和 删除 其中的元素)

>>> classmates = [ 'Michael', 'LoL', 'Bob']
>>> classmates
['Michael', 'LoL', 'Bob']
#变量 classmates  就是一个 list

len() 函数

可以获得list 元素 个数

>>> len(classmates)
3

索引 访问 list中每一个元素位置                        索引从 0 开始

>>> classmates[0]
'Michael'
>>> classmates[1]
'LoL'
>>> classmates[2]
'Bob'
>>> classmates[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
#索引超出了范围时   Python会报一个  IndexError 错误
#确保索引不要越界   最后一个元素的索引是    len(classmates) – 1

-1做索引      直接获取最后一个元素

>>> classmates[-1]
'Bob'
>>> classmates[-2]
'LoL'
>>> classmates[-3]
'Michael'
>>> classmates[-4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range

.append()  追加 末尾

list中 追加 元素到末尾

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

.insert() 插入 指定

插入 到指定位置              比如 索引号为 1 的位置

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

pop()  删除 末尾

删除 list 末尾元素

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

pop(i)  删除 指定

删除 指定 位置元素       i 是 索引位置

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

替换

把某个元素 替换 成别的元素       可以直接赋值给对应的索引位置

>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

数据类型可不同

>>> L = ['Apple', 123, True]
#list元素也可以是另一个list
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
#'php'可以写p[1]或者s[2][1]

空

list中一个元素也没有   就是一个空的list    长度为0

>>> L = []
>>> len(L)
0

tuple

另一种有序列表叫 元组：tuple

tuple和list非常类似   但tuple一旦初始化就不能修改

>>> classmates = ('Michael', 'Bob', 'Tracy')
#列出同学名字

classmates这个tuple不能变   它也没有append()  insert()

其他获取元素的方法和list是一样的  你可以正常地使用classmates[0] classmates[-1]但不能赋值成另外的元素

不可变的tuple有什么意义？

因为tuple不可变  所以代码更安全            如果可能  能用tuple代替list就尽量用tuple

定义 tuple

在定义时     tuple的元素  必须被确定下来

>>> t = (1, 2)
>>> t
(1, 2)

空 ()

如果要定义一个空的tuple       可以写成()

>>> t = ()
>>> t
()

一个元素

定义一个只有1个元素的tuple

>>> t = (1)
>>> t
1

注意: 定义的不是tuple        是1这个数！

因为括号 () 既可以表示tuple，又可表示数学公式中的小括号

因此    Python规定   这种情况下   按小括号进行计算     计算结果自然是1

只有1个元素   tuple   定义     必须加一个逗号  ,

>>> t = (1,)
>>> t
(1,)
#Python在显示只有1个元素的tuple时 也会加一个逗号, 以免误解成数学计算意义上的括号

特殊 “可变的” tuple

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

tuple定义    3个元素   分别是'a'   'b' 和 一个list

list的元素'A'和'B' 修改为' X'和'Y' tuple变为：

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。

tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

必须保证tuple的每一个元素本身不能变

条件判断

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

age = 20
if age >= 6:
print('teenager')
elif age >= 18:
print('adult')
else:
print('kid')

input()

input() 返回的数据类型是 str

str 不能直接和整数比较     str转换成整数

Python提供了  int()函数

s = input('birth: ')
birth = int(s)
if birth < 2000:
print('00前')
else:
print('00后')

模式匹配

if 语句

score = 'B'
if score == 'A':
print('score is A.')
elif score == 'B':
print('score is B.')
elif score == 'C':
print('score is C.')
else:
print('invalid score.')

match 语句

在最后（且仅能在最后）加一个case _表示“任意值”

score = 'B'

match score:
case 'A':
print('score is A.')
case 'B':
print('score is B.')
case 'C':
print('score is C.')
case _: # _表示匹配到其他任何情况
print('score is ???.')

复杂匹配

match语句   可匹配   多个值  匹配一定范围  

并且把匹配后的值绑定到变量

age = 15

match age:
case x if x < 10:
print(f'< 10 years old: {x}')
case 10:
print('10 years old.')
case 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18:
print('11~18 years old.')
case 19:
print('19 years old.')
case _:
print('not sure.')

•   case x if x < 10  表   age < 10  成立时匹配     且赋值给变量x
•   case 10    仅匹配单个值
•   case 11|12|…|18 匹配多个值         用|分隔

匹配列表

#用 args = ['gcc', 'hello.c', 'world.c'] 存储
args = ['gcc', 'hello.c', 'world.c']
# args = ['clean']
# args = ['gcc']

match args:
# 如果仅出现gcc，报错:
case ['gcc']:
print('gcc: missing source file(s).')
# 出现gcc，且至少指定了一个文件:
case ['gcc', file1, *files]:
print('gcc compile: ' + file1 + ', ' + ', '.join(files))
# 仅出现clean:
case ['clean']:
print('clean')
case _:
print('invalid command.')

• case ['gcc']   表示列表仅有'gcc'一个字符串    没有指定文件名     报错
• case ['gcc', file1, *files]   表示列表第一个字符串是'gcc'  第二个字符串绑定到变量file1   后面的任意个字符串绑定到*files   实际上表示至少指定一个文件
• case ['clean']   表示列表仅有'clean'一个字符串
• case _   表示其他所有情况

循环

for … in …. 循环

计算 1 – 10 整数之和：

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum = sum + x
print(sum)

range(）函数

range()函数   可 生成一个 整数序列    再通过 list()函数 转换为 list

比如 range(5) 生成的 序列 是从 0 开始 小于5 的 整数

>>> list(range(5))
[0, 1, 2, 3, 4]

计算 1 – 100 整数之和：

sum = 0
for x in range(101):
sum = sum + x
print(sum)

while 循环

条件满足   不断循环

条件不满足  退出循环

100以内所有奇数之和:

sum = 0
n = 99
while n > 0:
sum = sum + n
n = n – 2
print(sum)

break

可 提前 退出循环

n = 1
while n <= 100:
if n > 10: # 当n = 11时，条件满足，执行break语句
break # break语句会结束当前循环
print(n)
n = n + 1
print('END')

continue

跳过 当前这次循环   直接开始  下一次循环

n = 0
while n < 10:
n = n + 1
if n % 2 == 0: # 如果n是偶数，执行continue语句
continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
print(n)

dict 和 set

dict

Python内置了字典：dict的支持    dict全称 dictionary   在其他语言中称 map  使用键-值（key-value）存储  具有极快的查找速度

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

key 放入

>>> d['Adam'] = 67
>>> d['Adam']
67

一个 key 对应 一个 value         —–>        后面的值  会把 前面的值 冲掉

如果 key 不存在    dict  报错

避免key不存在方法：

 in  判断key 是否存在

>>> 'Thomas' in d
False

get() 方法

如果key不存在     可以返回None  或  自己指定 value：

>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

注意：返回None  Python交互环境 不显示 结果

pop(key) 方法    删除一个key

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

对应的 value 也会从 dict 中删除

list 和 dict 比较

dict

dict的key必须是不可变对象

list

set

set 和 dict 类似   是一组key的集合   不存储value

key 不能重复   在 set 中 没有重复的 key

>>> s = {1, 2, 3}
>>> s
{1, 2, 3}

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

>>> s = {1, 1, 2, 2, 3, 3}
>>> s
{1, 2, 3}

add(key)  添加 元素 可重复 添加(无效果)

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

remove(key)  删除 元素

>>> s.remove(4)
>>> s
{1, 2, 3}

交集    并集

>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set 和 dict 比较

唯一区别仅在于 没有 存储对应的value  

set原理 和 dict 一样     不可以放入可变对象  因为无法判断两个可变对象是否相等 

不可变对象

list 可变对象         str 不变对象

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

replace()  方法

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

a 是 变量     'abc'是 字符串对象

a —> 'abc'

a.replace('a', 'A') 调用 方法replace 是作用在 字符串对象'abc' 上 没有改变字符串'abc'的内容

replace方法  创建 一个新 字符串'Abc' 并 返回  

a —> 'abc'

b—-> 'Abc'

不可变对象 调用自身方法 不会修改 原对象 而是返回新对象 原对象始终保持不变