Python-1
python程序的组成:
程序由模块组成
模块由语句，函数，类，数据等组成
语句包含表达式
表达式建立并处理数据对象
python 注释
以 # 号开头，至直行尾
python 核心数据类型：
数字(整型int，浮点型float，复数complex, 布尔型bool)
字符串
列表等
整型数int
整型数是不带小数部分的数字。包括自然数，0,及负数
如 : -5, 10000, 0等
整型数的字面值表示方式:
十进制表示:
10
200
99999999
9999999999999999999999999999999999
二进制表示(0b开头,后跟0~1):
0b111
0b101
0b11111111
八进制方式表示(0o开头，后跟0~7)
0o177 # 127
0o11 # 9
十六进制表示(0x开头,后跟0~9, A~F,a-f)
0x11 # 17
0xFF # 255
0x1234ABCD
进制转换:
十进制(逢十进一)
二进制(逢二进一)
八进制(逢八进一)
十六进制(逢十六进一)
浮点型数 float
浮点型数是带有小数部分的数字
表示方式:
小数形式:
3.14 3.1 3. 0.14 .14
科学计数法:
格式:
小数 e/E(正负号) 指数
如:
6.18E-1
2.9979e8
复数 complex
分为两部分:
实部(real)
虚部(image)
虚部以j或J结尾
字面值
1j, (2j), 1+1J, 3-4J, (-100+100J)
布尔类型数bool
用来表示真和假两个状态的类型
True 表示真(条件满足或成立)
Flase表示假(条件不满足或不成立)
说明:
True 的值为1
False 的值为0
空值 None 对象
None 是一个表示不存在的特殊对象
作用:
用来占位
用来变量解除绑定
表达式和运算符(也叫操作符)
表达式 expression
由一个数字或数字和运算符组成
作用:
通常让计算机做一些事情并返回结果
例:
1 + 2
运算符:
算术运算符:
+ 加法
- 减法
* 乘法
/ 除法
// 地板除
% 求余
** 幂运算
除法:
除法得到的数是浮点数，不会丢弃小数部分
1/3 = 0.3333333333333333
4/2 = 2.0
// 地板除
除的结果去掉小数部分向下取整
7 / 3 # 得2.333333333333
7 // 3 # 得2
8 // 3 # 得2
3.25 // 1.5 # 得 2.0
% 求余(也叫取模)
10 % 3 # 得 1
3.25 % 1.5 # 得 0.25
** 幂运算
格式:
x ** y
意为 x 的 y次方
4 ** 2 # 得 16
3.0 ** 4.0 # 得 27
5.6 ** 1.418 # 得
运算符的优先级
**
* / // %
+ -
示例:
1 + 3 * 3 ** 2 + 4 // 2
1 + 27 + 4 // 2
1 + 27 + 2
28 + 2
30
括号分组子表达式
用()可以将表达式分组，()内的表达式先进行计算
混合类型自动升级
1 + 2.14 返回浮点数 3.14
基本输出函数：print
格式：print（要打印的数据），各个数据可以用逗号“，”隔开
示例：print('hello')
print(1+2+3)
变量 variable
什么是变量：
用来绑定数据对象的标识符
变量的命名规则：
1. 变量名必须为字母或下划线开头，后跟字母或下划线或数字
2. 不能使用python的关键字命名
赋值语句 statement
语法：
变量名 = 表达式
或
变量名1 = 变量名2 = 表达式
或
变量名1 ，变量名2，... = 序列
作用：用于创建变量并将变量绑定（或关联）在一个对象上
说明：
1.当变量不存在时，创建该变量同时绑定在这个对象上
2.当变量存在时，改变此变量的绑定的对象
3.一个变量只能绑定一个对象
4.两个变量可以同时绑定同一个对象
示例:
a = 10 # 创建a变量，和10绑定在一起
b = 20
c = a + b #创建变量c,和10 + 20 的结果绑定在一起
is / is not运算符
作用：判断两个对象是否绑定同一个对象，如果是同一个对象返回Ture,否则返回 False
is not 与 is 相反
语法：x is y
x is not y
a = 10000
b = 10000
a is b # False
id 函数：
格式：id(对象)
作用：返回一个对象在内存中的地址
del 语句（del 是 delete 的简写）
作用：用于删除变量，同时删除与对象的绑定关系。如果可能则释放对象
语法：del 变量名
python 的内存管理和引用计数
每个对象都会记录有几个变量引用自身，当引用的数量为0时，则对象被销毁，此种自动化内存管理的方式叫引用计数。
复合赋值算术运算符：
运算符说明
y += x 等同与 y = y + x
y -= x 等同与 y = y - x
y *= x 等同与 y = y * x
y /= x 等同与 y = y / x
y %= x 等同与 y = y % x
y //= x 等同与 y = y // x
y **= x 等同与 y = y ** x
比较运算符:
< 小于
<= 小于等于
> 大于
>= 大于等于
== 等于
!= 不等于
语法:
左表达式 < 右表达式
说明:
比较运算符返回布尔类型的值
示例:
10 < 20 # True
1 + 10 > 2 + 8 # True
10 < 20 <= 30 # True
内建的数值型函数:
abs(x) 取x的绝对值
round(number[, ndigits]) 对数值进行四舍五入， ndigits是小数向右取整的位数,负数表示向左取整
pow(x, y, z=None) 相当于 x ** y 或 x ** y % z
语句 statement
语句是由一些表达式等组成，通常一条语句可以独立执行来完成一部分事情并形成结果
一条语句建议写在一行内
多条语句写在一行内需要用分号(;) 分开
示例:
print('hello')
x = 100 + 200
print(x)
# 写在一起为:
print('hello'); x = 100 + 200; print(x)
换行:
显示换行:
折行号 \
隐藏式换行:
所有的括号内换行，称为隐式换行
括号: (), [], {}
示例：
i = 1 + 2 + 3 \
+ 4 + 5
print(i) # 15 用'\'显式换行
i = (1 + 2 + 3
+ 4 + 5) # 括号要成对出现，会隐式换行直到找到对应的括号为止
基本输入输出
基本输入函数 input
作用
从标准输入设备上读取一个字符串(末尾的换行符会被删除)
格式:
input('提示字符串')
说明：
返回输入的字符串(仅python3)
'提示字符串' 可以为空
# 此示例示意input函数的用法
s = input("请输入字符串: ")
print("您输入的字符串是:", s)
基本输出函数 print
作用：
将一系列的值以字符串形式输出到标准输出设备上，默认为终端
格式
print(value, ..., sep=' ', end='\n')
选项的关键字参数为:
sep 两个值之间的分隔符，默认为一个空格
end 输出完毕后在流末尾自动追加一个字符，默认为换行符'\n'
if 语句
作用：
让程序根据条件选择性的执行某条语句或某些语句
说明：
if 语句又叫条件语句，也叫分支语句
语法:
if 真值表达式1:
语句块1
elif 真值表达式2:
语句块2
elif 真值表达式3:
语句块3
if 语句的真值表达式
if 100:
print("真值")
# 等同于
if bool(100):
print("真值")
bool(x) 返回假的情况:
x为:
0, 0.0, 0+0j, False, None,
''(空字符串)
[] 空列表
{} 空字典
set() 空集合
() 空元组
if语句嵌套
if语句本身是由多条子句组成的一条复合语句
if语句可以作为语句嵌套到另一个语句的内部
条件表达式
语法:
表达式1 if 真值表达式 else 表达式2
作用：
如果真值表达式的布尔环境值为True,则执行表达式1并返回结果的引用，否则执行表达式2并返回结果的引用
pass 语句
作用：
通常用来填充语法空白
pass 语句又名空语句
语法:
pass
布尔运算:
运算符:
not and or
布尔非操作 not
语法:
not x
作用：
对 x进行布尔取值,如 bool(x) 为True,则返回False, 否则返回True
示例:
not True # False
not False # True
not 100 # False
布尔与操作 and
语法:
x and y
注: x, y代表表达式
作用：
优先返回假值对象
当bool(x)的值为False时，返回x,否则返回y
示例:
True and True # True
True and False # False
False and True # False
False and False # False
布尔或操作
语法:
x or y
作用：
优先返回真值对象,
当x为True时返回x, 否则返回y
示例:
True or True # True
True or False # True
False or True # True
False or False # False
100 or 200 # 100
100 or 0.0 # 100
0 or 200 # 200
0 or 0.0 # 0.0
正负号运算符:
+(正号) -(负号)
语法:
+ 表达式
- 表达式
示例:
a = 5
b = -a
c = +a
字符串 str
作用
用来记录文本（文字）信息
字符串的表示方法
在非注释中，凡是用引号括起来的部分都是字符串
' 单引号
" 双引号
''' 三单引号
""" 三双引号
in / not in 运算符
作用:
in 用于序列，字典，集合中，用于判断某个值是否存在于容器中，如果存在则返回True, 否则返回False
格式:
对象 in 容器
示例:
s = 'welcome to tarena!'
'to' in s # True
'weimingze' in s # False
字符串的索引操作
python 字符串str是不可以改变的字符序列
索引 index
索引语法
字符串[整数表达式]
说明
python 序列都可以用索引(index) 来访问序列中的对象(元素)
python 序列的正向索引是从0开始的，第二个索引为1,最后一个索引为len(s) -1
python 序列的反向索引是从-1开始的，-1代表最后一个，-2代表倒数第二个，第一个是-len(s)
示例:
s = 'ABCDE'
print(s[0]) # A
print(s[1]) # B
print(s[4]) # E
切片 slice
作用:
从字符串序列中取出一部分相应的元素重新组成一个字符串
语法:
字符串[(开始索引b):(结束索引e)(:(步长s))]
注: () 内括起的部分代表可以省略
说明:
1. 开始索引是切片开始切下的位置0代表第一个元素，-1代表最后一个元素
2. 结束索引是切片的终止索引(但不包含终止索引)
3. 步长是切片每次获取完当前索引后移动的方向和偏移量
1) 没有步长，相当于取值完成后向后移动一个索引的位置（默认为1)
2) 当步长为正整数时，取正向切片:
步长默认值为1, 开始索引默认值为0, 结束索引的默认值为len(s)
3) 当步长为负整数时，取反向切片:
反向切片时，默认的起始位置为最后一个元素，默认终止位置为第一个元素的前一个位置
示例:
s = 'ABCDE'
a = s[1:4] # a -> 'BCD'
a = s[1:] # a -> 'BCDE'
a = s[:2] # a -> 'AB'
a = s[:] # a -> 'ABCDE'
a = s[4:2] # a -> ''
a = s[2:10000] # a -> 'CDE' 开始索引/结束索引可以越界
a = s[::2] # a -> 'ACE'
a = s[1::2] # a -> 'BD'
a = s[::-1] # a -> 'EDCBA'
a = s[::-2] # a -> 'ECA'
a = s[4:0:-2] # a -> 'EC'
Python3中常用的序列函数:
len(seq) 返回序列的长度
max(x) 返回序列的最大值元素
min(x) 返回序列的最小值元素
示例:
s = "ABCD"
print(len(s)) # 4
print(max(s)) # D
print(min(s)) # A
字符串编码转换函数
ord(c) 返回一个字符串的Unicode编码值
chr(i) 返回i这个值所对应的字符
示例:
print(ord('A')) # 65
print(ord('中')) #
整数转换为字符串函数
hex(i) 将整数转换为十六进制的字符串
oct(i) 将整数转换为八进制字符串
bin(i) 将整数转换为二进制字符串
字符串的构造(创建)函数 str
str(obj='') 将对象转换为字符串
示例:
s = 123
print(str(s) + '456') # 123456
字符串格式化表达式
运算符
%
作用:
生成一定格式的字符串
语法:
格式字符串 % 参数值
格式字符串 % (参数值1, 参数值2, ...)
格式字符串中的 % 为占位符,占位符的位置将用参数值替换
格式化字符串中的占位符和类型码
占位符 意义
%s 字符串,使用str函数转换
%r 字符串,使用repr函数转换
%c 整数转为单个字符
%d 十进制整数
%o 八进制整数
%x 十六进制整数(a-f小写)
%X 十六进制整数(A-F大写)
%e 指数形浮点数(e小写) 如: 2.9e+10
%E 指数形浮点数(E大写) 如: 2.9E+10
%f, %F 浮点十进制形式
%g, %G 十进制形式浮点数或指数浮点数自动转换
%% 等同于一个%字符
占位符和类型码之间的格式语法
% [格式语法] 类型码
格式语法：
- 左对齐
+ 显示正号
0 补零
宽度(整数)
宽度.精度(整数)
示例:
'%10d' % 123 # ' 123'
'%-10d' % 123 # '123 '
'%10s' % 'abc' # ' abc'
'%-5s' % 'abc' # 'abc '
'%05d' % 123 # '00123'
'%7.3f' % 3.1415926 # '003.142'
循环语句
while 语句
for 语句
while 语句:
作用：
根据一定条件，重复的执行一条语句或多条语句
语法:
while 真值表达式:
语句块
else:
语句块
while 语句语法说明:
1. 先执行真值表达式，判断True/False
2. 如果为True则执行语句块1,然后跳转到第1步
3. 如果为 False则执行else子句部分的语句块2.然后结束此while语句的执行.如果没有else子句，则直接结束此while语句
4. else 子句部分可以省略(同if语句类似)
while 注意事项:
1. 要控制真值表达式来访问死循环
2. 通常用真值表达式内的变量来控制循环条件
3. 通常要在循环语句块内改变循环变量来控制循环的次数和变量的走向
while 语句嵌套
while 语句本身是语句，和其它语句一样，可以放在其它复合语句的内部
while 嵌套示意
while 真值表达式:
...
while 真值表达式2:
...
else:
...
...
else:
...
break 语句
作用：
用于循环语句(while,for语句)中，用来终止当前循环语句的执行
break说明
1. 当break语句执行后，此循环语句break之后的语句将不再执行
2. break语句通常和if语句组合使用
3. break语句终止循环时，循环语句的else子句的语句将不会执行
4. break语句只能终止当前循环语句的执行，如果有循环嵌套时，不会跳出嵌套的外重循环
5. break 语句只能在循环语句(while或for语句)内部使用
死循环:
死循环是指循环条件一直成立的循环
死循环通常用break语句来终止循环
死循环的else子句永远不会执行
示例:
while True:
n = int(input("请输入: "))
if n == 0:
break
print(n)
for 语句
作用：
用来遍历可迭代对象的数据元素
可迭代对象是指能依次获取数据元素的对象
可迭代对象包括:
字符串 str
for 语句语法:
for 变量列表 in 可迭代对象:
语句块1
else:
语句块2
for 语法说明:
1. 可迭代对象每次提供一个元素依次赋值给变量列表中的变量，赋值完毕后执行语句块1,重复执行此步骤，直到可迭代对象不能提供数据为止
2. 可迭代对象提供完所有元素后，执行else子句部分的语句块２，然后退出此for语句
3. else子句部可以省略（同while语句类似)
4. 当在循环内部用break终止循环时，else子句部分语句不会执行
range函数
格式见:
>>> help(range)
函数:
range(stop) 从零开始，每次生成一个整数后加１操作，直到stop为止（不包含stop)
range(start, stop[, step]) 从start开始，每次生成一个整数后移动step，直到stop为止(不包含stop,且step可以是负整数)
作用:
用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)
说明:
range返回的对象是可迭代对象.可以用于for语句中
示例:
range(4) # 生成0,1,2,3
range(3, 6) # 生成 3, 4, 5
range(1, 10, 2) # 生成 1,3,5,7,9
range(5, 0, -2) # 生成 5,3,1
range(4, 0) # 空
continue 语句
作用:
用于循环语句(while, for语句)中，不再执行本次循环内continue之后的语句，重新开始一次新的循环
说明:
1. 在while语句中，执行continue语句将会直接跳转到while语句的真值表达式处重新判断循环条件
2. 在for语句中，执行 continue语句，将会从可迭代对象中取下一个元素，绑定变量后再次进行循环
列表 list
列表是由一系列特定元素组成的，元素和元系之间没有任何关联关系，但他们之间有先后顺序关系
列表是一种容器
列表是序列的一种
列表是可以被改变的序列
python中的序列类型简介(sequence)
字符串 str
列表 list
元组 tuple
字节串 bytes
字节数组 bytearray
创建空列表的字面值
L = [] # L绑定空列表
创建非空列表:
L = [1, 2, 3, 4]
L = ["北京", "上海", "重庆"]
L = [1, 'two', 3, '四']
L = [1, 2, [3.1, 3.2, 3.3], 4]
列表的构造(创建)函数list
list() 生成一个空的列表 等同于[]
list(iterable) 用可迭代对象创建一个列表
示例:
L = list() L 为空列表,等同于 L = []
L = list("ABCD") # L->['A','B','C','D']
L = list(range(1, 10, 2))
列表的运算:
算术运算
+ += * *=
+ 用于拼接列表
x = [1,2,3]
y = [4,5,6]
z = x + y # z = [1,2,3,4,5,6]
+=用于原列表与左侧可迭代对象进行拼接,生成新的列表
x = [1,2,3]
x += [4,5,6] # x = [1,2,3,4,5,6]
x = [1,2,3]
x += 'ABC' # += 右侧必须是可迭代对象
* 生成重复的列表
x = [1,2,3] * 2 # x = [1,2,3,1,2,3]
*= 用于生成重复的列表，同时用变量绑定新列表
x = [1, 2]
x *= 3 # x = [1,2,1,2,1,2]
列表的比较运算:
运算符:
< <= > >= == !=
示例:
x = [1,2,3]
y = [2,3,4]
x != y # True
x > [1,2] # True
x < y # True
[1,3,2] > [1,2,3] # True
['AB', 'CD'] > ['AC', 'BD'] # False
[1, 'two'] > ['two', 1] # TypeError
range(start, stop[, step])
列表的 索引 index / 切片 slice
列表的索引语句:
列表[整数表达式]
用法:
列表的索引取值与字符串的索引取值规则完全相同
列表的索引为分正向索引和反向索引
示例:
L = ['A', 2, 'B', 3]
print(L[1]) # 2
x = L[2] # x = 'B'
列表的索引赋值
列表是可变的序列，可以通过索引赋值改变列表中的元素
语法:
列表[索引] = 表达式
示例:
x = [1,2,3,4]
x[2] = 3.14 # 改变了第三个元素的值
列表的切片
列表[:]
列表的[::]
列表的切片取值返回一个列表，规则等同于字符串的切片规则
示例:
x = list(range(9))
y = x[1:9:2] # y = [1,3,5,7]
列表的切片赋值语法:
列表[切片] = 可迭代对象
说明:
切片赋值的赋值运算符的右侧必须是一个可迭代对象
示例:
L = [2,3,4]
L[0:1] = [1.1, 2.2]
print(L) # [1.1, 2.2, 3, 4]
L = [2,3,4]
L[:] = [7,8]
L = [2,3,4]
L[1:2] = [3.1, 3.2, 3.3]
L = [2,3,4]
L[1:1] = [2.1, 2.2] # [2, 2.1, 2.2, 3, 4]
L = [2,3,4]
L[0:0] = [0, 1] # L=[0, 1, 2,3,4]
L = [2,3,4]
L[3:3] = [5,6] # L=[2,3,4, 5,6]
L = [2,3,4]
L[1:2] = []
切片步长不为1的切片赋值:
L = list(range(1, 9))
L[1::2] = [2.2, 4.4, 6.6, 8.8]
print(L) #
del 语句用于删除列表元素
语法:
del 列表[索引]
del 列表[切片]
示例:
L = [1,2,3,4,5,6]
del L[0] # L = [2,3,4,5,6]
del L[-1] # L = [2,3,4,5]
L = [1,2,3,4,5,6]
del L[::2] # L = [2, 4, 6]
python3中常用的序列函数:
len(x) 返回序列的长度
max(x) 返回序列的最大值元素
min(x) 返回序列中最小值元素
sum(x) 返回序列中所有元素的和(元素必须是数值类型)
any(x) 真值测试, 如果列表中其中一个值为真值则返回True,否则返回False
all(x) 真值测试，如果列表中所有值为真值，则返回True,只要有一个为假，则返回False
字符串文本解析方法 split 和 join
S.split(sep=None) 将字符串，使用sep作用为隔符分割S字符串，返回分割后的字符串的列表，当不给定参数时，用空白字符作为分隔符进行分割
S.join(iterable) 用可迭代对象中的字符串，返回一个中间用S进行分隔的字符串
例:
s = 'Beijing is capital'
L = s.split(' ') # L = ['Beijing', 'is', 'capital']
s = '\\'
L = ['C:', 'Programe files', 'python3']
s2 = s.join(L) # s2 = b'C:\Programe files\python3'
浅拷贝
是指在复制过程中只复制一层变量，不会复制深层变量绑定的对象的复制过程
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = L1.copy() # 等同于 L1[:] 浅拷贝
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1) # [1, 2, [3.14, 3.2]]
print(L2) # [1, 2, [3.14, 3.2]]
深拷贝
import copy # 导入copy模块
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = copy.deepcopy(L1) # 深拷贝
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.14, 3.2]]
列表推导式 list comprehension
列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式
作用：
用简易方法生成列表
语法:
[表达式 for 变量 in 可迭代对象]
或
[表达式 for 变量 in 可迭代对象 if 真值表达式]
示例:
# 以下生成一个数值为1~9的平方的列表
L = [x*x for x in range(1, 10)]
列表推导式的嵌套:
语法:
[ 表达式1
for 变量1 in 可迭代对象1 if 真值表达式1
for 变量2 in 可迭代对象2 if 真值表达式2
...]
示例:
L1 = [2, 3, 5]
L2 = [7, 11, 13]
# 将L1中的全部元素与L2中的全部元素依次相乘后放到列表L3中
L3 = [x * y for x in L1 for y in L2]
print(L3)
