python的数据类型,语句
七: ..更新中..
数字类型
整型数 int (整型数是不带有小数部分的数据,包括自然数,0,负数)
整型字面值的表示方式:
十进制表示 10 -100
八进制方式表示(0o开头,后跟0~7) 0o11 (9) 0o177 (127)
十六进制表示(0x开头,后跟0~9,A-F或 a-f)
注:a表示10, b表示11, ... f表示15 0x11 (17) 0xFF (255) 0x1234abcd 十进制的表示(ob开头,后跟0~1) 0b111 (7) 0b1000 (8)
---------------------------------------------
浮点型数 float
浮点型数是带有小数部分的数字(小数部分可以是0)
浮点型数的两种表示方式:
小数形式:
3.14 3.1 3.0 3. 0.14 .14
科学计数法
格式:小数e/E(正负号)指数
如:6.18E-1 (等同于 0.618)
2.9979e8 # 等同于 299790000.0
----------------------------------------------
复数 complex
分为两部分:
实部(real)
虚部(image)
注:虚部是以j或J结尾的
复数的字面值表示
1j
(2J)
1+1J
1-1j
(-100+100J)
-----------------------------------------------
布尔型数 bool
用来表示真和假两种状态的类型
True 表示真(条件满足可成立)
False 表示假(条件不满足或不成立)
说明:
True 的值是1
False 的值是0
字符串型
字符串 str (string)
作用:用来记录文字信息
表示方法:在非注释中凡是用引号括起来的部分都是字符串
' 单引号
" 双引号
''' 三单引号
""" 三双引号
空字符串的字面值的表示方式
''
""
''''''
""""""
注:空字符串的布尔测试值bool(x)为 False
非空字符串的字面值
'hello'
"hello"
'''hello'''
"""hello"""
单引号和双引号的区别:
单引号内的双引号不算结束符
双引号内的单引号不算结束符
示例:
print("I'm a teacher")
print('I am "weimingze"')
三引号字符串
以'''或"""开头,以'''或"""结尾的字符串
作用:
三引号字符串中的换行会自动转换为换行符'\n'
三引号内可以包含单引号和双引号
隐式字符串字面值的拼接
"I'm Teacher." 'I am "weimingze"'
得到的字符串等同于
'''I'm Teacher.I am "weimingze"'''
------------------------------------------------
raw 字符串(原始字符串)
格式:
r"字符串内容"
r'字符串内容'
r"""字符串内容"""
r'''字符串内容'''
作用:让转义字符 '\' 无效
字符串字面值中用字符反斜杠 \ 后跟一些字符代表特殊的一个字符
转义字符表:
\'代表一个单引号
\"代表一个双引号
\n 代表一个换行符
\\ 代表一个反斜杠
\r 返回光标至行首
\t 水平制表符
\f 换页
\v 垂直制表符
\b 倒退(backspace)
\0 字符串,字符值为0
\0oo oo为两位八进制表示的字符
\xXX XX为两位十六进制表示的字符
\uXXXX Unicode 16的十六进制的字符
\UXXXXXXXX Unicode32 的十六进制表示的字符
用转义序列代表特殊字符
-------------------------------------------------
字符串的运算:
运算符:+ += * *=
+ 加号运算符用于拼接字符串
+= 用于拼接运算后改变原变量的绑定关系
示例:
x = "abcd" + "efg"
print(x) # abcdefg
x += '123'
print(x) # abcdefg123
* 运算符生成重复的字符串
x = "ABCD" * 3 # x = 'ABCDABCDABCD'
y = 2 * "123" # y = '123123'
注: 字符串只能和整数相乘
*= 生成重复的字符串并改变原变量的绑定关系
x = '123'
x *= 2 # x = '123123'
y = 3
y *= "ABC" # y = 'ABCABCABC'
-------------------------------------------------
字符串格式化表达式
作用:生成一定格式的字符串
运算符:%
语法格式:
格式字符串 % 参数值
或
格式字符串 % (参数值1, 参数值2, ...)
说明:
% 左侧为格式字符串
% 右侧为参数值,当有多个参数值是用括号() 括起来,并用逗号(,)分隔
格式化字符串中以%开头的为占位符,占位符的位置将用参数值替换
示例:
fmt = "name: %s, age: %d"
s = fmt % ('weimingze', 35)
print(s) # name: weimingze, age: 35
%s 字符串,使用 str(x) 将x转换为字符串%r 字符串,使用 repr(x) 将x转换为字符串%c 整数转为单个字符%d 转为十进制整数%o 转为八进制整数%x 十六制进整数(字符a-f小写)%X 十六制进整数(字符A-F大写)%e 指数型浮点数(e小写), 如2.9e+10
%E 指数型浮点数(E大写), 如2.9E+10
%f, %F 浮点数(小数形式)%g, %G 十进制浮点数或指数浮点自动转换%% 等同于一个%字符
格式化字符串中的占位符和类型码
占位符和类型码之间的格式化语法:
% [- + 0 宽度.精度] 类型码
- : 左对齐
+ : 显示正号
0 : 左侧空白位置补零
宽度 : 整个字符串的字符个数
精度 : 保留小数点后多少位(默认6位)
"%10d" % 123 #' 123'
"%+10d" % 123 #' +123'
"%-10d" % 123 #'123 '
"%10s" % 'abc' #' abc'
"%-5s" % 'abc' #'abc '
"%010d" % 123 #'0000000123'
"%7.3f" % 3.141592535897932 #' 3.141'
"%07.2f" % 3.141592535897932 #'0003.14'
示例:
字符串的运算:
运算符:+ += * *=
+加号运算符用于拼接字符串+=用于拼接运算后改变原变量的绑定关系
示例:
x= "abcd" + "efg"
print(x) #abcdefg
x += '123'
print(x) #abcdefg123
*运算符生成重复的字符串
x= "ABCD" * 3 #x = 'ABCDABCDABCD'
y = 2 * "123" #y = '123123'
注: 字符串只能和整数相乘*=生成重复的字符串并改变原变量的绑定关系
x= '123'x*= 2 #x = '123123'
y = 3y*= "ABC" #y = 'ABCABCABC'
--------------------------------------------------字符串的比较运算
运算符:< <= > >= == !=示例:'A' < 'B' #True
'AB' <= 'AC' #True
'ABC' > 'ACB' #False
'AD' > 'ABC' #True
'AB' < 'ABC' #True
'ABC' == 'abc' #False
'ABCD' != 'DCBA' #True
-----------------------------------------------------
in / not in运算符
作用:in用于序列,字典,集合中,用于判断某个值是否存在于容器中,如果存在返回True, 否则返回False
说明:not in返回结果与in 相反
格式:
对象in序列
示例:
x= 'welcome to tarena!'
'to' in x #True
'e t' in x #True
'hello' in x #False
'hello' not in x #True
字符串的运算:
索引 index
python字符串是不可以改变的序列,
所有的序列都可以通过索引来获取其中的数据元素
语法:字符串[整数表达式]
说明:
1. 序列的正向索引是从0开始的,第二个索引为1,最后一个索引为len(s)-1
2. 序列的反向索引是从-1开始的,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)
切片 slice
从字符串序列中取出相应的元素重新组成一个字符串序列
语法:s[(开始索引b):(结束索引e)(:(步长s))]
注: 小括号() 括起的部分代表可省略
说明:
1. 开始索引b是切片切下的位置,0代表第一个元素,1代表第二个元素 -1代表最后一个元素...
2. 结束索引是切片的终止索引(但不包含终止点)
3. 步长是切片每次获取完当前元素后移动的方向和偏移量
3.1 没有步长,相应于步长为1(默认为1)
3.2 当步长为正整数时,取正向切片,开始索引默认为0,结束索引为最后一个元素的下一个位置
3.3 当步长为负数时,取反向切片.
反向切片时,默认的起始位置为最后一个元素.终止位置是第一个元素的前一个位置
s = 'ABCDE'a= s[1:4] #a---> 'BCD'
a = s[1:] #a---> 'BCDE'
a = s[0:2] #a---> 'AB'
a = s[:2] #a---> 'AB'
a = s[:] #a---> 'ABCDE'
a = s[1:1] #'' 空
a = s[4:1] #'' 空
a = s[1:4:2] #'BD'
a = s[::2] #'ACE'
a = s[4:0:-1] #a---> 'EDCB'
a = s[::-1] #'EDCBA'
a = s[4::-2] #'ECA'
示例:
字符串编码转换函数:
ord(c) 返回一个字符c的Unicode编码值
chr(i) 返回i这个值所对应的字符
示例:
print(ord('A')) # 65
print(ord('中')) # 20013
print(chr(65)) # A
print(chr(2345)) # ???
------------------------------------------------------
整数转字符串的函数:
bin(i) 将整数转换为二进制字符串
oct(i) 将整数转换为八进制字符串
hex(i) 将整数转换为十六进制字符串
列表类型
列表 list
问题:如何将计算机运算的数据临时保存在一个地方,同时又方便添加,删除和修改等操作
答案:容器
列表的定义:
列表是一种容器
列表是可以被改变的序列
列表是由一系列特定元素组成的,元素与元素之间可能没有任何的关联关系,但他们之间有先后顺序关系
创建空列表的字面值表达式
[] # 创建一个空列表
L = [] 变量L绑定一个新创建的空列表
创建非空的列表的字面值:
L = [1, 2, 3, 4]#L绑定一个新创建且含有四个元素的列表
L = ['Beijing', 'Shanghai', 'Shenzhen']
L = [1, 'Two', 3.14, '四']
L = [1, 2, [3.1, 3.2, 3.2], 4]
列表的构造函数 list
list() 生成一个空的列表,等同于 []
list(iterable) 用可迭代对象创建一个列表
示例:
L = list() # L = []
L = list("hello") # L = ['h','e','l','l','o',]
L = list(range(5)) # L = [0, 1, 2, 3, 4]
-----------------------------------------------------------
列表的运算:
算术运算:+ += * *= (运算规则与字符串的运算规则相同)
+ 用于拼接列表,生成新的列表
x = [1, 2, 3]
y = [4, 5, 6]
z = x + y # z = [1,2,3,4,5,6]
+= 用原列表与右侧可迭代对象追加来修改原列表
语法:列表变量 += 可迭代对象
示例:
# += 是改变原来的列表对象,并不会创建新的列表
x = [1, 2, 3]
print(id(x))
x += [4, 5, 6]
print(id(x))
* 生成重复的列表
x = [1, 2] * 3 # x = [1,2,1,2,1,2]
*= 生成重复的列表,并改变对变量的绑定
x = [1, 2, 3]
x *= 4 # x = [1,2,3,1,2,3,1,2,3,1,2,3]
列表的比较运算:
运算符:< <= > >= == !=
比较规则与字符串的比较规则相同
示例
----------------------------------------------------------
列表的 in / not in 运算符
判断一个值是否存在于列表中，如果存在返回True,否则返回 False
同字符串的 in 运算符 用于检查一个值是否存在于列表中，如果存在返回True, 否则返回False
示例:
x = [1, 'Two', 3, '四']
3 in x # 返回 True
'3' in x # 返回 False
10 in x # False
10 not in x # True
-----------------------------------------------------------
列表的索引操作
语法:列表[整数表达式]
用法:与字符串索引的用法相同(分为正向索引和反向索引)
示例:
x = [1,3,5,7]
print(x[1]) # 3
print(x[-1]) # 7
列表的索引赋值:
列表是可变的，可以通过索引赋值改变列表中的元素
语法:列表[整数表达式] = 表达式
作用:改变列表中索引的绑定关系
示例:
x = [1, 2, 3, 4]
x[2] = 3.14 # 改变了第三个元素的值
---------------------------------------------------------
列表的切片
列表[:]
列表[::]
列表的切片取值返回一个新的列表，规则等同于字符串切片规则
列表的切片赋值:
作用:
可以改变原列表的数据排列，可以插入和修改数据
可以用切片改变列表的对应元素的值
语法:
列表[切片] = 可迭代对象
说明:切片赋值的赋值运算符(=) 的右侧必须是一个可迭代对象
L = [2, 3, 4]
L[0:1] = [1.1, 2.2] #L = [1.1, 2.2, 3, 4]
L[2:] = [3.3, 4.4, 5.5] #L = [1.1, 2.2, 3.3, 4.4, 5.5]
L[:] = [3, 4] #L = [3, 4]
L[0:0] = [1, 2] #L = [1, 2, 3, 4]
L = [3, 4]
L[1:1] = [3.14] #L = [3, 3.14, 4]
L = [3, 4]
L[-1:-1] = [5, 6] #L = [3, 4, 5, 6]
L = [2, 3, 4]
L[1:2] = "ABC" #L = [2, 'A', 'B', 'C', 4]
L = [2, -1, 7]
L[1:2] = range(3, 7) #L=[2, 3, 4, 5, 6, 7]
示例
切片的注意事项:
对于步长不等于1的切片赋值,赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数
示例:
L = [1, 2, 3, 4, 5, 6, 7, 8]
L[1::2] = "ABCD" # 对的
L[1::2] = "ABCDEF" # 错的
---------------------------------------------------------
del 语句 用于删除列表的元素
语法:del 列表[索引]
如: del L[0]
del 列表[切片]
如: del L[1::2]
浅拷贝 shallow copy
浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程
示意:
L= [3.1, 3.2]
L1= [1, 2, L]
L2= L1.copy() #浅拷贝
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]]
深拷贝 deep copy
复制对象及对象关联的对象一起复制过程叫深拷贝
示意代码import 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]] <<< L1不变
print(L2) #[1, 2, [3.14, 3.2]]
深拷贝和浅拷贝
元组类型
元组 tuple
元组是不可改变的序列，同list一样，元组可以存放任意类型的元素
元组一但创建将不可改变
元组的表示方式:
用小括号() 括起来，单个元素括起来后加逗号(,)区分单个对象还是元组
创建空元组的字面值表达式
t = () # () 是创建一个空的元组对象
创建非空元组的字面值表达式:
t = 200,
t = (20,)
t = (1, 2, 3)
t = 100, 200, 300
注:type(x)函数 可以返回对象x的类型
元组的构造函数tuple
tuple() 生成一个空的元组 ，等同于()
tuple(iterable) 用可迭代对象生成一个元组
示例:
t = tuple()
t = tuple("ABC")
t = tuple(range(1, 10, 2))
元组的运算:
+ 用于用拼接方式创建一个新的元组
* 用于生成新的重复的元组
t = (1,2,3) + (4, 5, 6) # t = (1,2,3,4,5,6)
t += (7,8,9) # t = (1,2,3,4,5,6,7,8,9)
t = (1,2) * 3 # t = (1,2,1,2,1,2)
t *= 4 # t = (1,2,1,2,1,2....)
列表的比较运算:
< <= > >= == != 规则与列表的比较规则完全相同
元组的in / not in 运算符
用于判断元素是否存在于元组中,规则写列表完全相同
索引 index
用法等于同列表的索引
元组不支持索引赋值
切片
用法与列表的切片用法相同
元组的切片返回一个新的元组
元组不能切片赋值
元组的方法:
T.index(v[,begin[,end]]) 返回对应元素的索引下标， begin 为开始索引，end为结束索引，当v不存在时触发ValueError错误
T.count(x) 返回元组中对应的元素个数
字典类型
字典 dict
什么是字典:
1. 字典是一种可变的容器，可以存储任意类型的数据
2. 字典中的每个数据都是用'键'(key)进行索引的，而不像序列可以用索引下标进行索引
3. 字典中的数据没有先后顺序关系,字典的存储是无序的
4. 字典中的数据以键-值对(key-value)对形式进行映射存储
5. 字典的键不能重复,且只能用不可变类型作为字典的键
字典的字面值表示方法:
以{} 括起来,以冒号(:) 分隔键-值对,各键值对用逗号分隔开
创建空字典:
d = {} # {} 表达式用来创建一个空的字典
创建非空字典:
d = {'name': 'weimingze', 'age': 35}
d = {'a': 100}
d = {'a': tuple("ABC")}
d = {'abc': list("ABC")}
d = {'a': {'b':100, 'c':200}}
d = {True:'真值', False: '假值', None:'空', 100:'一百'}
d = {(1970, 1, 1): '计算机元年'}
字典的构造函数 dict
dict() 创建一个空的字典,等同于{}
dict(iterable) 用可迭代对象创建一个新的字典
dict(**kwargs) 用关键字传参形式创建一个新的字典
示例:
d = dict()
d = dict([('name', 'tarena'), ('age', 15)])
d = dict((['name', 'weimingze'], "AB"))
d = dict(name='Tarena', age=15)
字典的操作
字典的键索引
用[] 运算符可以获取字典内'键'对应的'值'
语法:v = 字典[键]
示例:
d = {'name': 'tarena', 'age': 15}
print(d['name'], '今年', d['age'], '岁')
添加/修改字典的元素
语法:字典[键] = 表达式
示例:
d = {}
d['name'] = 'tarena' #创建新的键'name'同时关联值
d['age'] = 15 # 创建键并绑定15
d['age'] = 16 # 修改原来的键'age',重新绑定为16
说明:
键不存在,创建键,并绑定值
键存在,修改键的绑定关系
-----------------------------------------------------------------------------------------------------------------
删除字典元素 del语句
del 字典[键]
示例:
d = {1:'一', 'hello': 'world', False:'假值'}
del d['hello']
--------------------------------------------------------------
字典的 in / not in 运算符
in用来判断一个键是否存在于字典中,如果存在返回 True,否则返回False
not in 的返回结果与in 相反
示例:
d = {'name': '小张', 'age': 20}
'name' in d # True
'age' not in d # False
'小张' in d # False (只判断键,不判断值)
20 not in d # True
------------------------------------------------------------
字典的迭代访问
字典是可迭代对象,字典只能对'键'进行访问
示例:
d= {'aaa': 111, 'bbb': 222, 'ccc': 333}
for k in d:
print(k)
可以用于字典的函数:
len(x) 返回字典的键值对个数
max(x) 返回字典键的最大值
min(x) 返回字典键的最小值
sum(x) 返回字典所有键的和
any(x) 真值测试,只对键进行测试
all(x) 真值测试,全部键为真值.结果才为True
示例:
d = {0: '零', 5:'伍', 8:'捌', 3:'叁'}
len(d) # 4
max(d) # 8
min(d) # 0
sum(d) # 16
any(d) # True
all(d) # False
-------------------------------------------------------
字典的方法
方法名 说明
D.clear() 清空字典
D.pop(key) 移除键,同时返回此键对应的值
D.copy() 返回字典D的副本(浅拷贝)
D.update(D2) 将字典D2合并到D中,如果键相同,则此键的值取D2的值为为新值
D.get(key, default=None) 返回键key所对应的值,如果没有此键,则返回Default的值
D.keys() 返回可迭代的dict_keys集合对象D.values() 返回可迭代的dict_value集合对象
D.items() 返回可迭代的dict_item对象
d = {1: 'One', 2: "Two"}
d2= {2: '二', 3: '三'}
d3= d.copy() #复制
d3.pop(1) #d3 = {2: "Two"}
d.update(d2) #d = {1: 'One', 2: '二', 3: '三'}
d= {1: 'One', 2: '二', 3: '三'}for k ind.keys():print(k) #1 2 3
for v ind.values():print(v) #'One' '二' '三'
for t ind.items():print(t) #(1, 'One') (2, '二') (3, '三')
示例:
字典推导式
是用可迭代对象生成字典的表达式
语法:{键表达式 : 值表达式 for 变量 in 可迭代对象[if 真值表达式]}
注: []表示其中的内容可省略
示例:
# 生成一个字典,键为数字 1 ~ 9,值为键的平方
d = {x : x ** 2 for x in range(1, 10)}
字典推导式的嵌套等同于列表推导式的嵌套
--------------------------------------------------------------------
字典 VS 列表
1. 都是可变对象
2. 索引方式,列表用整数索引,字典用键索引
3. 字典的插入,删除,修改的速度可能会快行列表(重要)
4. 列表的存储是有序的,字典的存储是无序的
示例:
L = [9, 4, 10043, 5, 12, 3......., 123]
1006 in L #
--------------------------------------------------------------------
集合类型
集合 set
集合是可变的容器
集合内的数据对象都是唯一的(不能重复多次的)
集合是无序的存储结构,集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代对象
集合是相当于只有键没有值的字典(键则是集合的数据)
创建空的集合:
set()
创建非空的集合的字面值:
s = {1, 2, 3}
集合的构造函数:
set() 创建一个空的集合(不能用{} 来创建空集合)
set(iterable) 用可迭代对象创建一个新的集合
示例:
s = set()
s = {2,3,5,7}
s = set("ABC") # s = {'A', 'B', 'C'}
s = set("ABCCBA") # s = {'A', 'B', 'C'}
s = set({1:"1", 2:'2', 5:'5'}) # s = {1, 2, 5}
s = set(('ABC', '123', True))
s = {True, None, "ABC", (1, 2, 3)}
---------------------------------------------------------
集合的运算:
交集& 并集| 补集- 对称补集^ 子集< 超集 >
& 用于生成两个集合的交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 & s2 # {2, 3}
| 生成两个集合的并集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 | s2 # {1, 2, 3, 4}
- 生成两个集合的补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} # 生成属于s1, 但属于 s2的所元素的集合
^ 生成两个集合的对称补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 ^ s2 # {1, 4}
> 判断一个集合是另一个集合的超集
< 判断一个集合是别一个集合的子集
s1 = {1, 2, 3}
s2 = {2, 3}
s1 > s2 # True
s2 < s1 # True
== != 集合相同/不同
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
in / not in 运算
in 同列表和字典的in运算符规则相同,如果存在于集合中返回 True,否则返回False
示例:
2 in {1, 2, 3} # True
集合是可迭代对象,可以用于for语句中
集合的方法:
详见:
>>> help(set)
集合推导式:
是用可迭代对象创建集合的表达式
语法:
{表达式 for 变量 in 可迭代对象 [if 真值表达式]}
[] 部分代表可省略
示例:
numbers = [1, 3, 5, 7, 9, 3, 4, 5, 6, 7]
s = {x ** 2 for x in numbers if x % 2 == 1}
print(s)
----------------------------------------------------------------
固定集合 frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
作用:
固定集合可以作为字典的键，也可以作为集合的值
固定集合的构造函数 frozenset
frozenset() 创建一个空的固定集合
frozenset(iterable) 用可迭代对象创建一个新的固定集合
示例:
fz = frozenset()
fz = frozenset("ABCAB")
fz = frozenset([1, 2, 3, 4, 5])
固定集合的运算:
& 交集
| 并集
- 补集
^ 对称补集
in / not in运算
> >= < <= == !=
(以上运算等同于集合的运算)
固定集合的方法:
相当于集合的全部方法去掉修改集合的方法
---------------------------------------------------------------------
扫一扫
2795
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
