1.列表，元组和字符串共有的特性
| 1. | 都可通过索引获取每一个元素 |
| 2. | 第一个元素的索引值都是0 |
| 3. | 都可以通过切片的方法获取一个范围 |
| 4. | 都有很多共同的运算符 |
Python将列表，元组和字符串统称为序列。根据是否能被修改这一特征，序列分为可变序列和不可变序列，列表是可变序列，而元组和字符串是不可变序列。
2.序列的有关函数
- 列表，元组和字符串的相互转换
list() 将一个可迭代对象转换为列表 tuple() 将一个可迭代对象转换为元组 str() 将一个可迭代对象转换为字符串
代码如下（示例）：
list("我爱python")
['我', '爱', 'p', 'y', 't', 'h', 'o', 'n']
list((1, 2, 3, 4))
[1, 2, 3, 4]
tuple([1, 2, 3, 4])
(1, 2, 3, 4)
tuple("我爱python")
('我', '爱', 'p', 'y', 't', 'h', 'o', 'n')
str([1, 2, 3, 4])
'[1, 2, 3, 4]'
str((1, 2, 3, 4))
'(1, 2, 3, 4)'-
min(iterable, *[, key, default]) min(arg1, arg2, *args[, key]) max(iterable, *[, key, default]) max(arg1, arg2, *args[, key]) min()和max()函数是通过对比传入的参数来返回最小值和最大值，其中min()和max()函数都有两种形式。当传入内容为空时，可通过设定default参数来设置返回的值。
代码如下（示例）：
s = [1, 1, 2, 3, 4]
min (s)
1
str = "I love Python"
max(str)
'y'
s = ()
min(s)
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
min(s)
ValueError: min() arg is an empty sequence
min(s, default = "内容为空")
'内容为空'
//也可直接传入多个参数
min (0, 1, 2, 3, 6)
0
max(0, 1, 2, 3, 6)
6- len()和sum()函数。而len()函数具有一定的限度，如果检测的对象超过了某个数值，就会报错，通常对于32位平台来说最大值是2的31次方减1，而对于64位平台来说最大的数值是2的63次方减1。而sum()函数有一个start参数，用于设定计算和求和的初始值。
代码如下（示例）：
len(range(2 ** 100))
Traceback (most recent call last):
File "<pyshell#15>", line 1, in <module>
len(range(2 ** 100))
OverflowError: Python int too large to convert to C ssize_t
s = [1, 0, 0, 8, 6]
sum(s)
15
sum(s, start = 100)
115-
sorted() 与sort()函数相似，也具有reverse和key参数，key参数指定的是一个干预排序的函数。不同的是sort()函数改变的是原函数，而sorted()函数返回的是一个全新函数，原函数不受影响。 reversed() 与reverse()函数相似，但该函数返回的是一个反向迭代器。 代码如下（示例）：
s = [1, 2, 3, 0, 6] sorted(s) [0, 1, 2, 3, 6] s [1, 2, 3, 0, 6] s.sort() s [0, 1, 2, 3, 6] sorted(s, reverse = True) [6, 3, 2, 1, 0] t = ["Apple", "Banana", "Pen", "Book"] sorted(t) ['Apple', 'Banana', 'Book', 'Pen'] sorted(t, key=len) ['Pen', 'Book', 'Apple', 'Banana'] s = [1, 2, 5, 8, 0] reversed(s) <list_reverseiterator object at 0x0000025F52281A50> list(reversed(s)) [0, 8, 5, 2, 1] s.reverse() s [0, 8, 5, 2, 1] -
代码如下（示例）：all()
判断可迭代对象中是否所有元素都为真 any() 判断可迭代对象中是否存在某个元素为真 x = [1, 1, 0] y = [1, 1,9] all(x) False all(y) True any(x) True any(y) True - enumerate()函数用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从0开始的序号共同构成一个二元组的列表，它还含有一个start参数来设置序号开始的值，默认值为0。
代码如下（示例）：
seasons = ["Spring", "Summer", "Autumn", "Winter"]
enumerate(seasons)
<enumerate object at 0x0000025F5232B340>
list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Autumn'), (3, 'Winter')]
list(enumerate(seasons, 10))
[(10, 'Spring'), (11, 'Summer'), (12, 'Autumn'), (13, 'Winter')]
- zip()函数用于创建一个聚合多个可迭代对象的迭代器。它会将作为参数传入的每个可迭代对象的每个元素依次组合成元组，即第i个元组包含来自每个参数的第i个元素，但需要注意的是如果参数的长度不一样，函数将会在最短的可迭代对象终止时结束这个操作。
代码如下（示例）：
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
list(zip(x, y, z))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
z = [8, 9, 10, 11, 12]
list(zip(x, y, z))
[(1, 4, 8), (2, 5, 9), (3, 6, 10)]- map()函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器，但需要注意的是函数将会在最短的可迭代对象终止时结束这个操作。
代码如下（示例）：
list(map(ord, "Python"))
[80, 121, 116, 104, 111, 110]
list(map(pow, [2, 3, 10], [5, 2, 3]))
[32, 9, 1000]
list(map(min, [1, 3, 9], [2, 2, 2], [0, 3, 6, 8]))
[0, 2, 2]- filter()函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回。语法：filter(function, iterable)。
- 一个迭代器肯定是一个可迭代对象，可迭代对象可以重复使用，而迭代器则是一次性的。 代码如下（示例）：
mapped = map(ord, "Python") for each in mapped: print(each) 80 121 116 104 111 110 list(mapped) [] - iter()函数将可迭代对象转换为迭代器。
代码如下（示例）：
x = [1, 2, 3, 4, 5]
y = iter(x)
type(x)
<class 'list'>
type(y)
<class 'list_iterator'>
- next()函数会逐个将迭代器中的元素给提取出来，当迭代器里没有任何元素时就会报错。但这个报错是异常，不是错误，异常是可控的，错误是不可控的，如果不想抛出异常，可以给该函数设置第二个参数。 代码如下（示例）：
next(y) 1 next(y) 2 next(y) 3 next(y) 4 next(y) 5 next(y) Traceback (most recent call last): File "<pyshell#80>", line 1, in <module> next(y) StopIteration next(y,"没有啦") '没有啦'
3.字典
- 字典是Python中唯一实现映射关系的内置类型。创建字典有以下多种方法。
代码如下（示例）：
a = {"吕布":"口口布", "关羽":"关习习", "刘备":"刘Baby"}
//直接使用大括号和冒号，将映射关系套牢
b = dict(吕布 = "口口布", 关羽 = "关习习", 刘备 = "刘Baby")
//使用dict()函数
c = dict([("吕布","口口布"), ("关羽","关习习"), ("刘备","刘Baby")])
//使用列表作为参数，列表中的每个参数是使用元组包裹起来的键值对
d = dict({"吕布":"口口布", "关羽":"关习习", "刘备":"刘Baby"})
//直接将第一种方法作为参数传入dict()函数
e = dict({"吕布":"口口布", "关羽":"关习习"}, 刘备 = "刘Baby")
//混合法
f = dict(zip(["吕布","关羽","刘备"], ["口口布", "关习习", "刘Baby"]))
//使用zip()函数
a == b == c == d ==e == f
True
//以上六种创建方法均等价- 增。
fromkeys(iterable[, values]) 可使用iterable参数指定的可迭代对象来创建一个新的字典，并将所有的值初始化为values参数指定的值。 代码如下（示例）：
d = dict.fromkeys("Fish", 250) d {'F': 250, 'i': 250, 's': 250, 'h': 250}该方法适用于从无到有创建一个所有键的值都相同的字典。在序列中元素是可以重复的，而字典中的键值对，一个键就对应一个值，并不会存在重复的键，重复了就会用新的值覆盖旧的值。
-
删。
pop(key[, default]) 可通过设置第一个参数来删除字典中的指定键值对。如果删除的值不存在，且不想抛出异常，可通过设置default参数。 popitem() 在Python3.7之前是随机删除一个键值对，在3.7之后他删除的是最后一个加入字典的键值对。 del关键字 可用于删除字典中的一个指定元素 clear() 清空字典中的所有内容 代码如下（示例）：
d {'F': 250, 'i': 250, 's': 250, 'h': 250} d.pop('s') 250 d {'F': 250, 'i': 250, 'h': 250} d.pop('p') Traceback (most recent call last): File "<pyshell#95>", line 1, in <module> d.pop('p') KeyError: 'p' d.pop('p', '没有该元素') '没有该元素' d.popitem() ('h', 250) d {'F': 250, 'i': 250} del d['i'] d {'F': 250} del d d Traceback (most recent call last): File "<pyshell#102>", line 1, in <module> d NameError: name 'd' is not defined. Did you mean: 'id'? d = dict.fromkeys("Fish", 250) d.clear() d {} -
update([other]) 可同时传入多个键值对，也可直接传入另一个字典或一个包含键值对的一个可迭代对象。 代码如下（示例）：
d = dict.fromkeys("FishC") d {'F': None, 'i': None, 's': None, 'h': None, 'C': None} d['s'] = 115 d {'F': None, 'i': None, 's': 115, 'h': None, 'C': None} d.update({'i':105, 'h':104}) d {'F': None, 'i': 105, 's': 115, 'h': 104, 'C': None} d.update(F='70', C='67') d {'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'} -
查。
代码如下（示例）：get(key[,default]) 可存入一个default参数指定找不到键的时候返回的值。 setdefault(key[, default]) 查找一个键是否存在字典中，如果在则返回它的值，若不在则给它指定一个新的值。 d['c'] Traceback (most recent call last): File "<pyshell#115>", line 1, in <module> d['c'] KeyError: 'c' d.get('c', "这里没有") '这里没有' d.setdefault('C', 'code') '67' d.setdefault('c', 'code') 'code' d {'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67', 'c': 'code'} -
items(),keys(),values()三个方法分别用于获取字典的键值对，键和值三者的视图对象。 代码如下（示例）：
d {'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67', 'c': 'code'} keys = d.keys() values = d.values() items = d.items() items dict_items([('F', '70'), ('i', 105), ('s', 115), ('h', 104), ('C', '67'), ('c', 'code')]) keys dict_keys(['F', 'i', 's', 'h', 'C', 'c']) values dict_values(['70', 105, 115, 104, '67', 'code'])
4.集合
- 集合中的所有元素都应该是独一无二的，并且也是无序的。创建集合有以下多种方法。代码如下（示例）：
{"Fish","Python"} {'Python', 'Fish'} //直接使用花括号，传入多种元素，传入的元素就是集合的元素 {s for s in "Python"} {'o', 'h', 'P', 'n', 'y', 't'} //使用集合推导式 set("Python") {'o', 'h', 'P', 'n', 'y', 't'} //使用set类型构造器 - 检测两个集合的关系。
isdisjoint() 检测两个集合是否相关 issubset() 检测该集合是否是另一个集合的子集 issuperset() 检测该集合是否是另一个集合的超集 代码如下（示例）：
s = set("FishC") s.isdisjoint("Python") False s.isdisjoint("Java") True s.issubset("FishC.com.cn") True s.issuperset("Fish") True - 两个集合的并集，交集，差集，对称差集。
union() 求该集合与另一个集合的并集，支持多参数。 intersection() 求该集合与另一个集合的交集，支持多参数。 difference() 求该集合与另一个集合的差集，支持多参数。 symmetric_difference() 求该集合与另一个集合的对称差集，只能有一个参数。 代码如下（示例）：
s.union({1,2,3}) {1, 2, 3, 'h', 's', 'C', 'i', 'F'} s.intersection("Fish") {'i', 'h', 's', 'F'} s.difference("Fish") {'C'} s.union({1,2,3}, "Python") {1, 2, 3, 'o', 'C', 'i', 'F', 'h', 's', 'P', 'n', 'y', 't'} s.intersection("Fish", "Phython") {'h'} s.difference("Fish", "Php") {'C'} s.symmetric_difference("Python") {'o', 's', 'C', 'i', 'P', 'n', 'y', 't', 'F'} - 运算符。使用运算符时，符号两边都必须是集合类型的数据。
<= 子集 < 真子集 >= 超集 > 真超集 | 并集 & 交集 - 差集 ^ 对称差集 代码如下（示例）：
s <= set("FishC") True s < set("FishC") False s > set("FishC") False s >= set("FishC") True s | {1, 2, 3}| set("Python") {1, 2, 3, 'h', 's', 'C', 'i', 'o', 'P', 'n', 'y', 't', 'F'} s & set("Php") & set("Python") {'h'} s - set("Php") - set("Python") {'i', 's', 'F', 'C'} s ^ set("Python") {'o', 'C', 'i', 'F', 's', 'P', 'n', 'y', 't'}
5.函数
- 创建和调用函数。代码如下（示例）：
def myfunc(): pass //函数定义，pass用来占坑 myfunc() //函数调用 - 函数的参数。从调用的角度，参数可以分为形式参数(形参)和实际参数(实参)两种。形参是函数定义时函数的名字，实参是函数调用时实际传进去的值。代码如下（示例）：
myfunc("我","打了","小甲鱼") '小甲鱼打了我' myfunc("小甲鱼","打了","我") '我打了小甲鱼' //位置参数 myfunc(o="我",vt="打了",s="小甲鱼") '我打了小甲鱼' //关键字参数 myfunc(o="我","打了","小甲鱼") SyntaxError: positional argument follows keyword argument //如果关键字参数和位置参数混合使用时，Python规定位置参数必须在关键字参数之前 def myfunc(s, vt, o="小甲鱼"): return "".join((o, vt, s)) myfunc("我","打了") '小甲鱼打了我' myfunc("我","打了","你") '你打了我' //默认参数，Python允许函数的参数在定义时就指定默认值，函数调用时如果没有传入实参，就将采用默认的参数值来代替 def myfunc(s="我", vt, o="小甲鱼"): return "".join((o, vt, s)) SyntaxError: non-default argument follows default argument //如果使用默认参数，默认参数必须放在后面 def myfunc(*args): print("有{}个参数。".format(len(args))) print("第2个参数是{}".format(args[1])) myfunc(1, 2, 3, 4, 5) 有5个参数。 第2个参数是2 //收集参数 - 闭包。在一个内部函数中，对外部作用域的变量进行引用，且一般外部函数的返回值为内部函数，那么内部函数就被认为是闭包的。代码如下（示例）：
def func_out(): x = 10 def func_inner(y): result = x + y print("结果:",result) return func_inner new_func = func_out() new_func(1) 结果: 11 - 装饰器。装饰器本质是一个Python函数，装饰器的实现是由闭包支撑的，在不改变原函数代码的前提下为函数增加额外的功能，装饰器的返回值也是一个函数的对象。装饰器实际上是一个闭包函数，但它的参数有且只有一个，且是函数类型的话，它才是装饰器，否则它就是闭包函数。代码如下（示例）：
import time def decorator(func): def inner(): begin = time.time() func() end = time.time() result = end - begin print("函数执行完成耗时", result) return inner @decorator def work(): for i in range(10000): print(i) work() - lambda表达式。在Python中使用lambda表达式表示匿名函数。语法：lambda 参数列表: lambda体。lambda体不能是一个代码块，不能包含多条语句，只能含一条语句，该语句会计算一个结果返回给lambda表达式，但不需要使用return语句返回。代码如下（示例）：
add_lambda = lambda a,b:a+b print(add_lambda(10,20)) 30 - 生成器。生成器是Python中的一个对象(按照某种规律，来生成元素的对象),生成器不是列表，保存了产生元素的算法，同时会记录游标的位置(现在拿到第几个元素了),为了下次继续拿数据，而不是从头开始拿数据。可以通过一直调用next()方法获取值，这个对象不保存数据，每次调用会返回一个值，既做到了列表的好处，又不占用空间。函数中使用了关键字yield，那这个函数就不再是一个普通的函数，而是一个生成器函数。生成器函数调用时，不会执行函数内部的代码，会直接返回一个生成器对象。关键字yield是直接用来生成一个数据的。代码如下（示例）：
def test1(number): a=0 b=1 n=0 while n < number: yield b a,b = b, (a+b) n += 1 return 'done' g = test1(6) print(g) <generator object test1 at 0x0000025F52326CE0> - 递归。一种计算过程，如果其中每一步都要用到前一步或前几步的结果，称为递归，用递归过程定义的函数，称为递归函数。递归的精髓在于通过不断地重复逼近一个最终结果。递归函数的调用包括直接调用和间接调用两种。代码如下（示例）：
def func(): print('in func') func() func() //直接调用，这是一个死循环 def foo(): print('in foo') bar() def bar(): print('in bar') foo() foo() //间接调用，这也是一个死循环 def foo(n): if n == 1: return 1 else: return n * foo(n-1) foo(5) 120
4933
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
