主要内容:
2、集合
3、元组
4、字典
复习:
字符串和元组一样,只能读不能写。列表和字典可以嵌套任何东西,列表可以嵌套列表
L = list("hello") # L = ['h', 'e', 'l', 'l', 'o']
集合、字典是无序的;列表、元组、字符串是有序的
集合、字典、列表是可以修改的;元组、字符串、数字是不能修改的
for 语句中的else 语句,意思是for中的循环结束后,再走else中的代码,字典中的键就相当于列表可中索引的数字
集合
集合是可修改的无序的不重复的序列,集合使用花括号{}
主要作用
去重,把一个列表变成集合,就自动去重了
关系测试,测试两组数据之前的交集、差集、并集等关系
创建集合
语法:set(可迭代对象)
创建空集合:s = set()
s = set([3,4,5,6,7]) #创建一个数字集合{3, 4, 5, 6, 7}
w = set([2,3,4])
t= set("hello")#遍历字符串中的每个字符,拆开成单个字符{'h', 'e', 'l', 'o'}
my_set1= set(("hello",)) #创建含有一个元素的集合,有逗号说明是元组
my_set2 = set(("haha","wode","en"))#创建一个含有多个元素的集合
print("s:",s) #s: {3, 4, 5, 6, 7}
print("w:",w) #w: {2, 3, 4}
print("my_set1:",my_set1) #{'hello'}
print("my_set2:",my_set2) #{'en', 'haha', 'wode'}
View Code
s.add() #添加集合
s.updata(可迭代对象) # 添加多项
s.remove(x) #删除指定元树x,如果x不存在则会发生错误
s.discard() #和remove()一样,但是当删除指定元素不存在时,不会报错
s.clear() #清空集合
s.pop() #弹出最后一个书或弹出指定数
s = set([4,5]) #创建一个数字集合{3, 4, 5}
s.add('w')print("添加后的s:",s) #{4, 5, 'w'}
s.update(['ni','hao','ya']) #添加多项
print("添加多项后的s:",s) #{'hao', 'ya', 4, 5, 'w', 'ni'}
#我们输入字符串试试
s.update("hid") #将字符串拆分单个字符后,然后再一个个添加到集合中,有重复的会忽略。,
print(s) #{'hao', 'ya', 4, 5, 'w', 'h', 'ni', 'i', 'd'}
s.remove("hao") #移除元素
print("移除元素",s) #{'w', 'e', 'o', 'l', 12, 'h', 23}
s.discard('ya') #移除元素,不存在不会发生错误
print(s) #{'d', 4, 5, 'i', 'ni', 'w', 'h'}
s.pop()#随机删除集合中的元素,这个方法返回值是删除的数,不是返回None
print(s) #{4, 5, 'i', 'ni', 'w', 'h'}
s.clear()print(s) #set()
View Code
| 生成两个集合的并集
& 生成两个集合的交集
- 生成两个集合的补集
^ 生成两个集合的对称补集(也就是两个集合的并集减去交集)
> 判断一个集合是另一个集合的超集
==, != 判断集合是否相同
in , not in 判断集合是否在另一个集合中
len(s), sum(s), max(s), min(s), sum(s), any(s), all(s)
s = set([3,4,5,6,7]) #创建一个数字集合{3, 4, 5, 6, 7}
w = set([2,3,4])print("求交集:",s&w) #{3, 4}
print("求并集:",s | w) #{2, 3, 4, 5, 6, 7}
print("求差集:",s-w) #减去相同的元素 {5, 6, 7}
print("求差集:",w-s) #减去相同的元素 {2}
print("并集减去交集:",s ^ w) #{2, 5, 6, 7}
print(len(s)) #5
print(3 in s) #True
View Code
固定集合 frozenset
固定集合是不可变、无序的,含有唯一元素的不可迭代的集合,
作用:固定集合可以作为字典的键,还可以作为字典的值
固定集合的构造函数
frozenset() 创建一个空的固定集合
frozenset(iterable) 用可迭代对象创建一个固定的集合
固定集合的运算和集合的运算完全一样
集合推导式: {表达式 for 变量 in 可迭代对象 [if 真值表达式]} # [ ]可以省略
集合推导式同样也可以嵌套
{x for x in range(10)} #返回集合
元组
元组是不可修改的有序序列,元组使用小括号(),列表使用综括号[],可以存储任意的数据类型
元组只含一个元素时,需要在后面添加逗号,否者会被当做变量来处理
括号可以省略
1 tuple2 = (1,2,'wo',4,5)2 print(tuple2) #(1, 2, 'wo', 4, 5)
3 tuple3 = "wo","ai","ni" #不需要括号也可以
4 print(tuple3) #('wo', 'ai', 'ni')
5 print(type(tuple3)) #类型为元组类型
6 tup1 = () #()
7 print(tup1)8 tup2 = (50) #不加逗号,类型为整型
9 print(tup2) #50,
10 tup3 = (50,) #加逗号,类型为元组
11 print(tup3) #(50,)
元组
1 t = tuple() #创建一个空元组
2 t = () #创建一个空元组
3 x, y, z = 100, 200, 300 #序列赋值1 2 3 x,y,z是整型
4 x, y, z = (100, 200, 300) #序列赋值 100 200 300整型
5 x, y, z = [100, 200, 300] #序列赋值
6 x, y, z = 'ABC' #序列赋值 A B C 字符串
7 T.index(v[, begin[, end]]) #返回对应元素的索引下标
8 T.count(x) #返回元组中对应的元素个数
1.访问元组
tup1 =(11,2,33)print("tup1[0]:",tup1[0]) #tup1[0]: 11
print("tup1[0:2]:",tup1[0:2]) #tup1[0:2]: (11, 2)
访问元组
2.删除元组
元组中的值是不能被删除的,但我们可以删除整个元组
tup = ('Google', 'Runoob', 1997, 2000)deltupprint ("删除后的元组 tup :",tup) #name 'tup' is not defined
删除整个元组
3、元组运算符
元组的相加和相乘是创建了一个新的元组,原来的元组并没有改变,也改变不了
Python 表达式
结果
描述
len((1, 2, 3))
3
计算元素个数
(1, 2, 3) + (4, 5, 6)
(1, 2, 3, 4, 5, 6)
连接
('Hi!',) * 4
('Hi!', 'Hi!', 'Hi!', 'Hi!')
复制
3 in (1, 2, 3)
True
元素是否存在
for x in (1, 2, 3); print (x)
1 2 3
迭代
4、元组索引,截取
L = ('Google', 'Taobao', 'Runoob')
Python 表达式
结果
描述
L[2]
'Runoob'
读取第三个元素
L[-2]
'Taobao'
反向读取;读取倒数第二个元素
L[1:]
('Taobao', 'Runoob')
截取元素,从第二个开始后的所有元素。
5、元组的其他内置函数
len max min
tuple(列表) 将列表转换成元组
6、reversed和sorted的使用
reversed(可迭代对象) # 返回反向顺序的可迭代对象(临时性的)
sorted(iterable, key=None, reverse=False) # 返回已排序的列表
t = (4, 8, 6, 2, 7)
L= [x for x inreversed(t)]#L = [7, 2, 6, 8, 4] # 原来先后顺序的反向
for x inreversed(t):print(x) #打印: 7 2 6 8 4
L2= sorted(t) #L2 = [2, 4, 6, 7, 8]
L3 = sorted(t, reverse=True) #L3 = [8, 7, 6, 4, 2]
字典
字典是可修改的无序序列,字典使用花括号{},可以存储任意类型对象,
字典由键值对组成{key:value}
键在字典中是唯一的,如果重复,后面的键值对会替换前面的。
键必须是不可变的类型对象,只能用数字、字符串、元组充当,列表就不行,值可以取任意的数据类型
d = {"key1":'value1',"key2":'value2'}print(d) #{'key2': 'value2', 'key1': 'value1'}
dict = {'a':2,'b':1,'b':3} #重复最后的一个键值对会替换前面的,值不需要唯一
print(dict) #{'a': 2, 'b': 3}
键值对
创建字典,
当键不存在时,创建键,并绑定对应的值,当键存在时,修改键绑定的值
#创建字典dict
dict1 = {'a':2,'b':1,'b':3} #重复最后的一个键值对会替换前面的,值不需要唯一
print(dict1) #{'a': 2, 'b': 3}
dict1['c'] = 4 #当键不存在时,增加键,并绑定对应的值,
print(dict1) #{'a': 2, 'b': 3, 'c': 4}
dict1['c'] = 134 #当键存在时,修改键绑定的值
print(dict1) #{'a': 2, 'b': 3, 'c': 134}
创建字典
访问字典,把键放入方括号中进行索引,但是访问字典中不存在的键会出错
1 print(dict['a'])#访问字典,把键放入方括号中进行索引
2 print(dict["c"])#访问字典中不存在的键会出错
访问字典
删除字典、清空字典、删除字典中的键值对
dict1 = {'a':2,'b':1,'c':3}del dict1['a'] #删除字典中的键"a,就相当于删除了值2
print(dict1) #{'b': 1, 'c': 3}
dict1.clear() #清空字典的所有键
print(dict1) #{}
del dict1 #删除字典
删除字典、清空字典、删除字典中的键值对
字典的内置函数
cmp(dict1, dict2)
# 比较两个字典元素。如果两个字典的元素相同返回0,
# 如果字典dict1大于字典dict2返回1,
# 如果字典dict1小于字典dict2返回-1。
len(dict) # 计算字典元素个数,即键的总数。
str(dict)# 输出字典可打印的字符串表示。
type(variable) # 返回输入的变量类型,如果变量是字典就返回字典类型。
字典方法
dict.clear()#删除字典内所有元素
dict.copy()#返回一个字典的浅复制
1 seq = ('Google', 'Runoob', 'Taobao')2 seq1 = 'fkjsahf'
3 dict =dict.fromkeys(seq)4 print("新字典为 : %s" %str(dict))5 dict = dict.fromkeys(seq, 10)6 print("新字典为 : %s" %str(dict))7 dict = dict.fromkeys(seq1, 10)8 print("新字典为 : %s" %str(dict))9
10 #新字典为 : {'Runoob': None, 'Taobao': None, 'Google': None}
11 #新字典为 : {'Runoob': 10, 'Taobao': 10, 'Google': 10}
12 #新字典为 : {'j': 10, 'k': 10, 'h': 10, 'a': 10, 'f': 10, 's': 10
View Code
1 dict = {'Name': 'Zara', 'Age': 27}2
3 print "Value : %s" % dict.get('Age')#Value : 27
4 print "Value : %s" % dict.get('Sex', "Never")#Value : Never
dict.get
1 dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}2
3 print "字典值 : %s" %dict.items()4
5 #遍历字典列表
6 for key,values indict.items():7 printkey,values8
9 #字典值 : [('Google', 'www.google.com'), ('taobao', #'www.taobao.com'), ('Runoob', 'www.runoob.com')]
10 #Google www.google.com
11 #taobao www.taobao.com
12 #Runoob www.runoob.com
dict.items()
dict.items()返回的是两个数,一个是字典的键,一个是字典的值,
1 dict = {'Name': 'Zara', 'Age': 7}2
3 print "Value : %s" % dict.keys()#Value : ['Age', 'Name']
dict.keys
1 site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}2 pop_obj=site.pop('name')3 print(pop_obj) #输出 :菜鸟教程
4 print(site) #{'alexa': 10000, 'url': 'www.runoob.com'}
site.pop()
序列相关函数:
len(),max(),min(),sum(),any(),all(){全部都为真都返回真}
列表中的方法:
L.index(v)#返回元素对应的索引下标
L.insert(index,obj)
L.count(x)
L.remove(obj)
L.copy()
L.append(x)
L.extend(lst)#L +=lit
L.clear()
L.sort()
L.pop(索引)
L.reverse()#列表的反转
深拷贝deep copy,浅拷贝shallow copy
字符串的方法:
str.split() 分割 把字符串的空格用逗号分隔,返回列表
str.join() 连接 字符串的分隔符换成join里面的数
小总结
1. 数据类型:
数值类型:
int, float, complex, bool
容器:
不可变的容器
str, tuple, frozenset, bytes(字节串)
可变的容器
list, dict, set, bytearray(字节数组)
有序的容器
str(字符串) list(列表) tuple(元组) bytes(字节串) bytearray(字节数组)
无序的容器
set(集合) dict(字典)
推导式总结:
列表:[x for x in range(10)]返回列表
集合:{x for x in range(10)}返回集合
字典:{x:x**2 for x in range(10)}返回字典
2.值:
None, False, True
3. 运算符
算术运算符
+ - * / //(保留整数) %(求余) **(平方)
比较运算符:
< <= > >= == !=
in / not in
is, is not
布尔运算:
not(非), and(与), or(或)
+(正号) -(负号)
&(按位与) |(按位或) ^(按位异或)~(按位取反)
[] (索引,切片,键索引)
表达式:
1
1 + 2
max(1,2,3) # 函数调用是表达式
x if x > y else y, 条件表达式,把三条语句融合为一条
语句
表达式语句:
所有的表达式都可以单独写在一行,形成一个语句,例:
print("hello world")
1 + 2
赋值语句:
a = 100
a = b = c = 100
x, y = 100, 200 #交叉赋值
a[0] = 100 #序列索引赋值
dict['name'] = 'tarena' 字典赋值
del 语句
if 语句
while 语句
for 语句
break 语句
continue语句
pass 语句
内建函数:
len(x), max(x), min(x), sum(x), any(x), all(x)
构造函数(用来创建同类型的数据对象)
布尔值 bool(x), int(x), float(x), complex(x),
list(x), tuple(x), str(x), dict(x), set(x),
frozenset(x)
abs(x)
round(x[,n])#四舍五入
1 print(round(80.63756, 2)) #80.64保留小数点后两位,对第三位进行四舍五入
2 print(round(56.6)) #57
round(x[,[n])
pow(x, y, z=None)
1 print(pow(2,2)) #2**2 = 4
2 print(pow(2,2,2)) #2 ** 2 % 2 = 0
pow(x,y[,z])
bin(x),返回一个整形int或者长整形long int的二进制表示
print(bin(10)) #0b1010
bin(int)
oct(x)将一个整数转换成8进制字符串
print(oct(10)) #0o12
oct(int)
hex(x)将10进制整数转换成16进制,以字符串形式表示
print(hex(195)) #0xc3
hex(int)
chr(x),用一个范围在0~255整数(ASCII)作参数,返回一个对应的字符
1 >>>print chr(0x30), chr(0x31), chr(0x61) #十六进制
2 0 1a3 >>> print chr(48), chr(49), chr(97) #十进制
4 0 1 a
chr(10进制或者16进制)
ord(x)以一个字符作为参数,返回对应的 ASCII 数值,或者 Unicode 数值,
1 >>>ord('a')2 97
3 >>> ord('b')4 98
5 >>> ord('c')6 99
ord("一个字符")
range(start, stop, step)
input(x), print(x)
Python 表达式结果描述
len((1, 2, 3))
3
计算元素个数
(1, 2, 3) + (4, 5, 6)
(1, 2, 3, 4, 5, 6)
连接
('Hi!',) * 4
('Hi!', 'Hi!', 'Hi!', 'Hi!')
复制
3 in (1, 2, 3)
True
元素是否存在
for x in (1, 2, 3); print (x)
1 2 3
迭代