主要内容：
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'}
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()
| 生成两个集合的并集
& 生成两个集合的交集
- 生成两个集合的补集
^ 生成两个集合的对称补集（也就是两个集合的并集减去交集）
> 判断一个集合是另一个集合的超集
< 判断一个集合是另一个集合的子集
==, != 判断集合是否相同
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
固定集合 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
)
del
tup
print
(
"
删除后的元组 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(列表) 将列表转换成元组
reversed(可迭代对象)
#
返回反向顺序的可迭代对象（临时性的）
sorted(iterable, key=None, reverse=False)
#
返回已排序的列表
t = (4, 8, 6, 2, 7
)
L
= [x
for
x
in
reversed(t)]
#
L = [7, 2, 6, 8, 4] # 原来先后顺序的反向
for
x
in
reversed(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()#返回一个字典的浅复制
dict.fromkeys(seq[, val]) #创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
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
dict.get(key, default=None) #返回指定键key的值，如果值不在字典中返回default值，default = None
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.has_key(key)
#如果键在字典dict里返回true，否则返回false
dict.items()
#以列表形式返回可遍历的(键, 值) 元组数组
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
in
dict.items():
7
print
key,values
8
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.keys() #以列表返回一个字典所有的键
1
dict = {
'
Name
'
:
'
Zara
'
,
'
Age
'
: 7
}
2
3
print
"
Value : %s
"
% dict.keys()
#
Value : ['Age', 'Name']
dict.setdefault(key, default=None)
#和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)
#把字典dict2的键-值对更新到dict里
dict.values()
#以列表返回字典中的所有值
pop(key[,default])
#删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
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'}
popitem() #随机返回并删除字典中的一对键和值。
序列相关函数：
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
pow(x, y, z=None)
1
print
(pow(2,2))
#
2**2 = 4
2
print
(pow(2,2,2))
#
2 ** 2 % 2 = 0
bin(x), 返回一个整形int或者长整形long int的二进制表示
print
(bin(10))
#
0b1010
oct(x) 将一个整数转换成8进制字符串
print
(oct(10))
#
0o12
hex(x) 将10进制整数转换成16进制，以字符串形式表示
print
(hex(195))
#
0xc3
chr(x), 用一个范围在0～255 整数 (ASCII)作参数，返回一个对应的 字符
1
>>>
print
chr(0x30), chr(0x31), chr(0x61)
#
十六进制
2
0 1
a
3
>>>
print
chr(48), chr(49), chr(97)
#
十进制
4
0 1 a
ord(x) 以 一个字符 作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，
1
>>>ord(
'
a
'
)
2
97
3
>>> ord(
'
b
'
)
4
98
5
>>> ord(
'
c
'
)
6
99
range(start, stop, step)
input(x), print(x)
