元组的函数
基本和list通用
1 a = (1, 2, 3, 4, 5, 6, 7, 8, 9)
2 print(len(a)) # 获取元组长度
3 print(max(a)) # 获取元组最大值
4 print(min(a)) # 获取元组最小值
5 l = [1, 5, 9]
6 t = tuple(l) # 将其他类型转换为tuple
元组变量交换法
1 a = 1
2 b = 2
3 a, b =b, a
4 print(a)
5 print(b)
集合 set
一堆确定的无序的唯一数据，每一个数据成为一个元素
1 a = set() # 定义一个空集合
2 print(type(a))
3 print(a)
4 a = {1, 2, 3, 4} # 定义一个集合，这种方法必须有元素否则是一个dict类型
5 print(type(a))
6 print(a)
集合的特征
数据无序，因此无法使用索引和切片
内部元素具有唯一性，无重复数据
集合序列操作
1 s = {9, 'I', 'Love', 'Python'}
2 print(s)
3 print('I' in s)
集合遍历操作
for循环
1 s = {9, 'I', 'Love', 'Python'}
2 for i in s:
3 print(i, end=" ")
带有元组的集合遍历
1 s = {(9, 6, 8), ('I', 'Love', 'Python')}
2
3 for k, m, n in s:
4 print(k, "---", m, "---", n)
5 for p in s:
6 print(p)
集合函数
intersection:交集
difference:差集
union:并集
issubset：检查一个集合是否是另一个子集
issuperset：检查一个集合是否为另一个超集
1 s1 = {1, 2, 3, 4, 5}
2 s2 = {5, 6, 7, 8, 9}
3 s_1 = s1.intersection(s2)
4 print(s1)
5 s_2 = s1.difference(s2)
6 print(s_2)
7 s_3 = s1.issubset(s2)
8 print(s_3)
冰冻集合 frozen set
不能修改的集合就叫做冰冻集合，是一种特殊集合
1 # 创建frozenset
2 s = frozenset()
3 print(type(s))
4 print(s)
dict字典
字典是一种组合数据，没有顺序的组合数据，数据以键值对的形式出现
1 # 创建空字典
2 d = {}
3 print(type(d))
4 d = dict()
5 print(type(d))
6 # 创建有值的字典
7 d = {"first": 1, "second": 2, "third": 3}
8 print(type(d))
9 print(d)
10 # 利用关键字创建字典
11 d = dict(first=1, second=2, third=3)
字典的特征
字典是序列类型，但是是无序序列，所以没办法分片和索引
key：必须是可哈希的值
value:可以是任何值
字典的常用操作
1 # 访问
2 d = {"first": 1, "second": 2, "third": 3}
3 print(d["first"])
4 print(d["second"]) #注意中括号内是键值
5 d["first"] = 'one'
6 print(d["first"])
7 # 删除
8 del d["first"]
9 print(d)
10 # 成员检测 in not in
11 # 成员检测检测的是key的内容
12 d = {"first": 1, "second": 2, "third": 3}
13
14 if 2 in d:
15 print("666")
16 if "first" in d:
17 print("999")
18
19 # 按key来使用for循环
20 d = {"first": 1, "second": 2, "third": 3}
21 for k in d:
22 print(k, d[k])
23
24 # 和上面的代码是一个操作
25 for k in d.keys():
26 print(k, d[k])
27
28 # 只访问字典的值
29 for v in d.values():
30 print(v)
31 # 特殊用法
32 for k, v in d.items():
33 print(k, '---', v)
字典生成式
1 d = {"first": 1, "second": 2, "third": 3}
2 # 常规生成式
3 dd = {k:v for k,v in d.items()}
4 print(dd)
5 # 带条件表达式的生成式
6 dd = {k:v for k,v in d.items() if v % 2 ==0}
7 print(dd)
字典相关函数
1 # 通用函数： len,max,min,dict
2 #str(字典):返回字典的字符串格式
3 d = {"first": 1, "second": 2, "third": 3}
4 print(str(d))
5
6 # clear:清空字典
7 d.clear()
8 print(d)
9 # iteams(): 返回字典的键值对组成的元组格式
10 d = {"first": 1, "second": 2, "third": 3}
11 i = d.items()
12 print(type(i))
13 print(i)
14 # keys：返回字典的键组成的结构
15 k = d.keys()
16 print(type(k))
17 print(k)
18 # values: 一个可迭代的结构
19 v = d.values()
20 print(type(v))
21 print(v)
22 # get:根据制定键的返回相应的值，好处是可以设置默认值
23 d = {"first": 1, "second": 2, "third": 3}
24 print(d.get("aaaaa"))
25 print(d.get("first",80))
26 print(d.get("aaaa", 8888))
27
28 #formkeys:使用指定的序列作为键，使用一个值作为字典的所有的键的值
29
30 a = ["one", "two", "three"]
31 d = dict.fromkeys(a, "niubi") # 这里要注意传递的参数类型
32 print(d)
面向对象编程-OOP
思想：接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型组成的
继承
封装
多态
类和对象的概念
抽象名词，代表一个大集合，共性的事物
对象：具象的事物，单个个体
类的基本实现
类的命名
遵守变量命名规范
避开和系统命名相似的命名
类的声明
必须用class关键字
类由属性和方法构成，其他不允许出现
类的实例化
变量 = 类命()
访问对象成员
obj.成员属性名称
obj.成员方法
可以通过内置变量检测类和对象的所有成员
对象所有成员检查
obj.__dict__
类所有的成员
class_name.__dict__
定义一个学生类
1 class Student(): # 类
2 pass
3
4 xiaowang = Student() # 对象
定义一个学PY的学生的类
1 class PyStdent():
2 name = None
3 age = 16
4 course = "Python"
5
6 def doHomework(self):
7 print("俺在做作业")
8 return None
9
10 # 实例化一个学生
11 xiaozhang = PyStdent()
12 print(xiaozhang.name)
13 print(xiaozhang.age)
14 xiaozhang.doHomework()