九、字符串

1、大小写字母换来换去

2、左中右对齐

3、实现字符串的查找功能

4、替换

5、字符串各种情况下的判断和检测

6、截取字符串

7、拆分和拼接

8、格式化字符串

9、f-字符串（f-string）

十、序列

1、能够作用于序列的运算符和函数

2、跟序列相关的一些函数

3、迭代器与可迭代对象

十一、字典

1、创建字典的六种方法

2、增，fromkeys()

3、删，pop()

4、改，update()

5、查，get()，setdefault()

6、字典的其他操作

7、嵌套

8、字典推导式

十二、集合

1、集合的三种创建方法

2、集合的各种内置方法

3、仅适用于set()的方法

4、可哈希

十三、函数

1、创建和调用函数

2、函数的返回值，return语句

3、函数的参数

（1）位置参数

（2）关键字参数

（3）默认参数

（4）' / '

（5）' * '

（6）收集参数

（7）解包参数

九、字符串

1、大小写字母换来换去

capitalize()：字符串首字母大写，其他小写

swapcase()：翻转字符串所有字母的大小写

title()：单词首字母大写，其他小写

upper()：全变大写

lower()：全变小写（只用于英文）

casefold()：全变小写（可用于英文以外的其他语言）

2、左中右对齐

center(width, fillchar='')：居中

rjust(width, fillchar='')：右对齐

Ijust(width, fillchar='')：左对齐

zfill(width)：用0填充字符串左侧，多用于数据报表

width参数用于指定字符串的宽度，若指定的宽度小于或等于原字符串，那么则直接输出源字符串

fillchar参数用于指定填充的字符，默认为空格

3、实现字符串的查找功能

count(sub[, start[, end]])：用于查找sub参数指定的子字符串在字符串中出现的次数

find(sub[, start[, end]])：用于定位sub参数指定的子字符串在字符串中的索引下标值

rfind(sub[, start[, end]])：同上，但是从右往左检索

index(sub[, start[, end]])：同find()，但是find在找不到对应的字符串会返回-1，index则抛出异常

rindex(sub[, start[, end]])：同上，但是从右往左检索

4、替换

expandtabs([tabsize=8])：使用空格替换制表符，参数是指定一个tab等于多少个空格

replace(old, new, count=-1)：返回一个将old参数指定的子字符串替换为new参数指定的字符串的新字符串，count为替换的次数，默认为-1，相当于替换全部

translate(table)：返回一个根据table参数转换后的新字符串，table用以指定一个转换规则的表格（加密），table表格需要使用str.maketrans(x, y, z)来获取

>>> table = str.maketrans('abcdefg','1234567')
>>> str = 'The quick brown fox jumps over a lazy dog.'
>>> str.translate(table)
'Th5 qui3k 2rown 6ox jumps ov5r 1 l1zy 4o7.'
>>> table = str.maketrans('abcdefg','1234567','xyz')
>>> str.translate(table)
'Th5 qui3k 2rown 6o jumps ov5r 1 l1 4o7.'

str.maketrans(x, y, z)：x：指定需要替换的字符。y：指定替换的目标字符。z：删除对应的字符

5、字符串各种情况下的判断和检测

startswith(prefix[, start[, end]])：判断参数指定的子字符串是否出现在字符串起始位置

endswith(suffix[, start[, end]])：判断参数指定的子字符串是否出现在字符串结束位置

start和end参数指定查找的开始和结束位置

以上两个方法的参数支持以元组的形式传入，同时查找多个子字符串。

isupper()：判断字符串中所有字母是否大写

islower()：判断字符串中所有字母是否小写

istitle()：判断字符串中所有单词是否以大写开头、其余字母小写

isalpha()：判断字符串中是否只由字母构成

isspace()：判断字符串中是否是空白字符串，空格、tab、转自字符、\n

isprintable()：判断字符串中是否所有字符串都是可打印的，\n为非打印字符

isdecimal()：判断是否为数字

isdigit()：同上

isnumeric()：同上

三个检测是否是数字的方法，能检测的范围不一样。例如isdecimal()只能检测123，isnumeric()可以检测罗马数字、中文数字等。根据不同的需求选择不同的方法。

isalnum()：检测是否为数字或者字母，只要isalpha()、isdecimal()、isdigit()、isnumeric()几个方法任何一个会返回True，它都会返回True

isidentifier()：判断字符串是否是一个合法的python标识符

isascii()：判断是否空字符串或字符串中每个字符都是ASCII编码的字符

判断一个字符串是否为python的保留标识符：keyword模块的iskeyword函数

以上方法返回都是布尔类型的值

6、截取字符串

strip(chars=None)：截掉字符串左侧和右侧的空白

Istrip(chars=None)：截掉字符串左侧的空白

rstrip(chars=None)：截掉字符串右侧的空白

char用来设置截掉的匹配字符，可以是多个字符，用一个字符串表示，默认是空白

removeprefix(prefix)：从前面截掉一个具体的子字符串

removesuffix(suffix)：从前面截掉一个具体的子字符串

>>> L = 'www.baidu.com'
>>> L.lstrip('wcom.')
'baidu.com'
>>> L.rstrip('wcom.')
'www.baidu'
>>> L.removeprefix('www.')
'baidu.com'
>>> L.removesuffix('.com')
'www.baidu'

7、拆分和拼接

partition(sep)：将字符串以参数指定的字符为分隔符对字符串进行拆分，从左边开始匹配，只匹配拆分一次，返回一个三元组

rpartition(sep)：同上，只是从右边匹配

split(sep=None, maxsplit=-1)：将字符串拆分成若干个字符串，sep：拆分的分隔符，默认空格，maxsplit：拆分次数，也就是匹配分隔符的次数

rsplit(sep=None, maxsplit=-1)：同上，但从右往左

splitlines(keepends=False)：将字符串按行进行分割，将结果以列表的形式返回，keepends参数用于设定返回的列表是否包含换行符本身，若为True，换行符将包含到上一个字符串中去。可以用于需要按行进行字符串分割，但不同平台换行符的转义字符不同的情况。

join(iterable)：将字符串拼接起来。join的效率比加号高很多，在大数量情况下甚至会快上千倍。

>>> '.'.join(['www', 'baidu', 'com'])
'www.baidu.com'
>>> ''.join(('L', 'o', 'v', 'e'))
'Love'

8、格式化字符串

format()：在字符串中使用一对花括号来表示替换字符串，替换的字符串为format()的参数，花括号中可以填上数字，表示引用参数的位置，同一个参数可以被引用多次，也可以使用关键字进行索引，参数中的字符串当做元组来处理。选项可以通过关键字参数来设置选项的值。

完整语法：format_spec::= [[fill]align][sign][#][0][width][grouping_option][.precision][type]

>>> '祖国的生日是{}年。'.format(1949)
'祖国的生日是1949年。'
>>> '{mounain}上有座{1}，{1}里有个{0}'.format('老和尚', '庙', mounain='山')
'山上有座庙，庙里有个老和尚'

[fill]：指定填充的符号

[align]：指定对其方式

‘<’：强制字符串在可用空间内左对齐(默认)

‘>’：强制字符串在可用空间内右对齐

‘=’：强制将填充放置在符号(如果有)之后但在数字之前的位置(这适用于以"+000000120"的形式打印字符串)

‘^’：强制字符串在可用空间内居中

[sign]：仅对数字类型有效

‘+’：正数在前面添加正好（+），负数在前面添加负号（-）

‘-’：只有负数在前面添加负号（-），默认行为

空格：正数在前面添加一个空格，负数在前面添加负号（-）

[0]：感知正负号的用0填充空白位置，只对数字有效

[width]：指定填充字符串的宽度

[grouping_option]：设置数字千分位的分隔符，有下划线和逗号

[.precision]：精度，※对于[type]设置为'f或'F'的浮点数来说,是限定小数点后显示多少个数位；

※对于[type]设置为'g'或'G'的浮点数来说,是限定小数点前后一共显示多少个数位；

※对于非数字类型来说,限定的是最大字段的大小

※对于整数类型来说,则不允许使用[.precision]选项

[type]：决定了数据如何来呈现

'b'：将参数以二进制形式输出

'c'：将参数Unicode字符形式输出

'd'：将参数以十进制形式输出

'o'：将参数以八进制形式输出

'x'：将参数以十六进制形式输出

'X'：将参数以十六进制形式输出

'n'：与‘d’类似，但会使用当前语言环境设置的分隔符插入到恰当的位置

None：同‘d’

[#]：参数以二进制、八进制或者十六进制在字符串中进行输出的时候会自动追加代表进制的前缀，配合[type]中的进制输出使用

以下适用于浮点数和复数

'e'：将参数以科学计数法的形式输出（以字母'e'来标示指数，默认精度为6）

'E'：将参数以科学计数法的形式输出（以字母'E'来标示指数，默认精度为6）

'f'：将参数以定点表示法的形式输出（“不是数”用'nan'来标示，无穷用'inf'标示，默认精度为6）

'F'：将参数以定点表示法的形式输出（“不是数”用'NAN'来标示，无穷用'INF'标示，默认精度为6）

'g'：通用格式，小数以'f'形式输出，大数以'e'的形式输出

'G'：通用格式，小数以'F'形式输出，大数以'E'的形式输出

'n'：跟'g'类似，不同之处在于它会使用当前语言环境设置的分隔符插入到恰当的位置

'%'：以百分比的形式输出（将数字乘以100并显示为定点表示法'f'的形式，后面附带一个百分号）

None：类似于'g'，不同之处在于当使用定点表示法时，小数点后将至少显示一位，默认精度与给定值所需的精度一致。

9、f-字符串（f-string）

直接在字符串前加（f-）即可，format方法的语法糖，f-字符串仅支持python3.6以上版本

十、序列

列表、元组和字符串都统称为序列

可分为可变序列和不可变序列，列表是可变序列，元组和字符串是不可变序列

1、能够作用于序列的运算符和函数

加号和乘号：+、*

is、is not：检测对象id值是否相等（不等），是否是（不是）同一个对象，叫同一性运算符

in、not in：用于判断某一个运算符是否包含（不包含）在序列中

del语句：用于删除一个或多个对象，或者删除可变序列中的指定元素del list[start: end]

clear()：清除列表中的元素

2、跟序列相关的一些函数

list()、tuple()、str()：列表、元组、字符串相互转换，参数为可迭代对象

min()、max()：对比传入的参数，返回最小值或者最大值，当传入的可迭代对象为空，且default未设置时会报错，若设置了default，则输出default指定的内容。

len()：在底层是直接读取C语言结构体里面的对象的长度，有一个能读取的最大长度，对于32为平台来说，这个长度是2^31-1，对于64位平台来说是2^63-1。

sum()：其中可选一个start参数，会将该参数加到求和的可迭代对象里面。

sorted()：返回一个全新的排序后的列表，与列表的sort()方法区分开。同样支持key与reverse参数，使用方法与sort()一致。可接受任何形式的可迭代参数。

reversed()：返回的是一个参数的反向迭代器，暂且当做一个可迭代对象来看。

>>> s = [1, 2, 3, 4, 5]
>>> reversed(s)
<list_reverseiterator object at 0x00000284AD4AF310>
>>> list(reversed(s))
[5, 4, 3, 2, 1]
>>> s.reverse()
>>> s
[5, 4, 3, 2, 1]
>>> list(reversed('上山打老虎'))
['虎', '老', '打', '山', '上']
>>> list(reversed((1, 2, 3, 7, 8, 9)))
[9, 8, 7, 3, 2, 1]
>>> list(reversed(range(10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

all()：判断可迭代对象中是否所有元素的值都为真。

any()：判断可迭代对象中是否存在某一个元素的值为真。

enumerate()：用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从0开始的序号共同构成一个二元组的列表。start参数：用于指定序号开始的值。

>>> s = ['虎', '老', '打', '山', '上']
>>> enumerate(s)
<enumerate object at 0x00000284AD183480>
>>> list(enumerate(s))
[(0, '虎'), (1, '老'), (2, '打'), (3, '山'), (4, '上')]
>>> list(enumerate(s, 5))
[(5, '虎'), (6, '老'), (7, '打'), (8, '山'), (9, '上')]

zip()：用于创建一个聚合多个可迭代对象的迭代器。他会将作为参数传入的每个可迭代对象的每个元素一次组合成元组，即第i个元组包含来自每个参数的第i个元素。

若传入的可迭代对象的长度不相等，则以最短的为准，将多余的元素抛弃。若不想丢弃多余的元素，则可以使用itertools模块中的zip_longest()函数来代替zip()。

>>> sing = [1, 2, 3, 4]
>>> song = [5, 6, 7, 8]
>>> zip(sing, song)
<zip object at 0x00000284AD4B6F40>
>>> list(zip(sing, song))
[(1, 5), (2, 6), (3, 7), (4, 8)]>>> z = [11, 22, 33, 44, 55]
>>> list(zip(sing, song, z))
[(1, 5, 11), (2, 6, 22), (3, 7, 33), (4, 8, 44)]>>> import itertools
>>> itertools.zip_longest(sing, song, z)
<itertools.zip_longest object at 0x00000284AD4CD720>
>>> list(itertools.zip_longest(sing, song, z))
[(1, 5, 11), (2, 6, 22), (3, 7, 33), (4, 8, 44), (None, None, 55)]

map()：根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器。

若提供的函数需要两个或者多个参数时，只需要同时去调整可迭代对象的数量即可。

若提供的可迭代对象的长度不一致时，以最短的可迭代对象为准，抛弃掉多余的。

>>> s = 'list'
>>> map(ord, s)#ord函数为返回字符的编码值
<map object at 0x0000023CCC91F2B0>
>>> list(map(ord, s))#每次从字符串s中取出一个字符，执行ord函数
[108, 105, 115, 116]#返回的则为‘l’‘i’‘s’‘t’四个字母的编码值>>> list(map(pow, [2, 3, 10],[4, 3, 2]))
[16, 27, 100]>>> list(map(max, [5, 7, 9], [3, 7, 564], [1, 4, 765, 2, 3]))
[5, 7, 765]

filter()：与map()函数类似，根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回。

>>> list(filter(str.islower, 'Love'))
['o', 'v', 'e']

3、迭代器与可迭代对象

一个迭代器肯定是一个可迭代对象。可迭代对象是可以重复使用的，但是可迭代器是一次性的

iter()：将一个可迭代对象变为一个迭代器。

>>> x = [1, 2, 3, 4, 5]
>>> y = iter(x)
>>> y
<list_iterator object at 0x0000023CCC895190>
>>> 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#18>", line 1, in <module>next(y)
StopIteration
>>> y = iter(x)
>>> next(y, '没有了')
1
>>> next(y, '没有了')
2
>>> next(y, '没有了')
3
>>> next(y, '没有了')
4
>>> next(y, '没有了')
5
>>> next(y, '没有了')#当next有第二个参数时，在提取完元素之后输出其指定的内容
'没有了'

十一、字典

字典是Python中唯一实现映射关系的内置类型。

映射关系：举例摩斯密码

使用Python实现摩斯密码解码

在映射类型的数据的获取上，字典的效率是远远高于列表的。

在序列中元素可以重复，字典中的键值对只有一个

1、创建字典的六种方法

冒号左边为字典的键，右边为字典的值。

获取：与序列所不同的是，序列是通过位置的偏移来存取数据的，而字典则是通过键来进行的，使用字典的值则需要在方括号中传入键即可。

改/增：通过对字典的键赋值，即可更改该键的值，若字典中无该键，则新增一个。

>>> x = {'1':'1', '2':'4', '3':'9', '4':'16', '5':'25'}
>>> type(x)
<class 'dict'>>>> x['4']
'16'>>> x['5'] = '50'
>>> x
{'1': '1', '2': '4', '3': '9', '4': '16', '5': '50'}
>>> x['6']  ='36'
>>> x
{'1': '1', '2': '4', '3': '9', '4': '16', '5': '50', '6': '36'}

（1）直接使用大括号和冒号的组合

（2）使用dict()函数，参数为键值对

（3）使用列表作为参数，列表中的元素是使用元组包裹起来的键值对

（4）将（1）中的语句作为参数传递给dict()

（5）混合使用以上几种方法

（6）通过zip()函数作为参数

>>> a = {'一':'1', '二':'4', '三':'9'}#（1）
>>> b = dict(一='1', 二='4', 三='9')#（2）
>>> c = dict([('一', '1'), ('二', '4' ), ('三', '9')])#（3）
>>> d = dict({'一':'1', '二':'4', '三':'9'})#（4）
>>> e = dict({'一':'1', '二':'4'}, 三='9')#（5）
>>> f = dict(zip(['一', '二', '三'], ['1', '4', '9']))#（6）
>>> a == b == c == d == e == f
True

2、增，fromkeys()

fromkeys(iterable[, values])：使用iterable指定的可迭代对象创建一个新的字典，并将所有值初始化为参数values指定的值

>>> x = dict.fromkeys(range(3), 520)
>>> x
{0: 520, 1: 520, 2: 520}

3、删，pop()

pop(key[, default])：返回key键所指的值，而后删除该键值对。

>>> x.pop(2)
520
>>> x.pop(2)
Traceback (most recent call last):File "<pyshell#16>", line 1, in <module>x.pop(2)
KeyError: 2
>>> x.pop(2, '没有该键')
'没有该键'

popitem()：python3.7之前是随机删除一个键值对，在3.7之后则是删除最后一个加入字典的键值对。

>>> x.popitem()
(1, 520)

del：删除指定的键值对，也可以删除字典

>>> del x[0]
>>> x
{}
>>> del x
>>> x
Traceback (most recent call last):File "<pyshell#22>", line 1, in <module>x
NameError: name 'x' is not defined

clear()：清空字典的内容

>>> x = {'1':'1', '2':'4', '3':'9', '4':'16', '5':'25'}
>>> x
>>> x.clear()
>>> x
{}

4、改，update()

直接对字典的某一个键进行赋值以修改耽搁单个值。

update([other])：同时对多个键值对进行修改，传入多个键值对、字典、包含键值对的可迭代对象

>>> x = dict.fromkeys('Love')
>>> x
{'L': None, 'o': None, 'v': None, 'e': None}>>> x['L'] = 100
>>> x
{'L': 100, 'o': None, 'v': None, 'e': None}>>> x.update({'o':101, 'v':102})
>>> x
{'L': 100, 'o': 101, 'v': 102, 'e': None}>>> x.update(v='103', e='104')
>>> x
{'L': 100, 'o': 101, 'v': '103', 'e': '104'}

5、查，get()，setdefault()

get(key[, default])：key为查找的键，default为未查到键时返回的数据。

>>> x['L']
100
>>> x['l']
Traceback (most recent call last):File "<pyshell#12>", line 1, in <module>x['l']
KeyError: 'l'
>>> x.get('L','没找到')
100
>>> x.get('l','没找到')
'没找到'

setdefault(key[, default])：查找字典中的数据，若找到则返回该值，找不到则新建一个键值对，新建的键值对的键为key，值为default。

>>> x.setdefault('L', '110')
100
>>> x.setdefault('l', '110')
'110'
>>> x
{'L': 100, 'o': 101, 'v': '103', 'e': '104', 'l': '110'}

items()、keys()、values()：分别用于获取字典的键值对、键、值三者的视图对象。视图对象即字典的动态视图，当字典的内容发生改变的时候，视图对象的内容也会相应的跟着改变。

>>> items = x.items()
>>> keys = x.keys()
>>> values = x.values()
>>> items
dict_items([('L', 100), ('o', 101), ('v', '103'), ('e', '104'), ('l', '110')])
>>> keys
dict_keys(['L', 'o', 'v', 'e', 'l'])
>>> values
dict_values([100, 101, '103', '104', '110'])>>> x.pop('l')
'110'
>>> x
{'L': 100, 'o': 101, 'v': '103', 'e': '104'}
>>> items
dict_items([('L', 100), ('o', 101), ('v', '103'), ('e', '104')])
>>> keys
dict_keys(['L', 'o', 'v', 'e'])
>>> values
dict_values([100, 101, '103', '104'])

6、字典的其他操作

（1）copy()：对字典进行浅拷贝

（2）len()：获取字典键值对的数量

（3）in()、notin()：判断某个键是否在（不在）字典中

（4）list()：将字典转换为列表，返回的是由字典的键构成的列表，等于list(x.keys())，想要得到字典的值组成的列表则需要使用list(x.values())

（5）iter()：将字典的键构成一个迭代器

（6）reversed()：对字典的键值对进行倒序，但是不能对python3.8之前的版本使用，因为之前的版本中的字典键值对是无序的。

7、嵌套

某个键的值可以是另外一个字典或者列表

>>> score = {'张三':{'语文':'70', '数学':'60', '英语':'45'}, \'小红':{'语文':'99', '数学':'98', '英语':'97'}}
>>> score
{'张三': {'语文': '70', '数学': '60', '英语': '45'}, '小红': {'语文': '99', '数学': '98', '英语': '97'}}
>>> score['张三']['英语']
'45'>>> score = {'张三':[70, 60, 45], '小红':[99, 98, 97]}
>>> score['小红'][2]
97

8、字典推导式

>>> score = {'语文':70, '数学':60, '英语':45}
>>> erocs = {i:j for j,i in score.items()}
>>> erocs
{70: '语文', 60: '数学', 45: '英语'}
>>> P = {i:j for i,j in score.items() if j>=60}
>>> P
{'语文': 70, '数学': 60}>>> x = {i:ord(i) for i in 'Love'}
>>> x
{'L': 76, 'o': 111, 'v': 118, 'e': 101}

十二、集合

>>> type({})
<class 'dict'>
>>> type({123})
<class 'set'>
>>> type({123:123})
<class 'dict'>

集合中所有元素都是无序的，所以不能使用下标索引的方式来对其进行访问。可以使用in和notin来判断元素是否存在于集合中。可以通过迭代的方式来访问全体集合元素。

集合中的所有元素都是唯一的，不能存在重复的元素。因此可以使用集合来对列表进行去重或者检测列表是否存在重复元素

1、集合的三种创建方法

（1）使用花括号，并在其传入多个元素

>>> {123, 123}
{123}
>>> {123, 456}
{456, 123}

（2）使用集合推导式

>>> s = {i for i in 'Love'}
>>> s
{'L', 'v', 'e', 'o'}

（3）使用类型构造器set()

>>> set('love')
{'e', 'v', 'o', 'l'}

2、集合的各种内置方法

下面列举的方法不会对集合的元素进行改动，所以既适用于可变集合set()，也适用于不可变集合frozenset()：

s.copy()：返回s集合的一个浅拷贝

s.isdisjoint(other)：如果s集合中没有与other 容器存在共同的元素，那么返回True，否则返回False

s.issubset(other)：如果s集合是 other容器的子集(注1)，那么返回True，否则返回False
注1:对于两个集合A、B，如果集合A中任意一个元素都是集合B中的元素，我们就说这两个集合有包含关系，称集合A为集合B的子集(Subset)（ <= 真子集、 < 子集）

s.issuperset(other)：如果s集合是 other容器的超集（注2)，那么返回True，否则返回False
注2∶对于两个集合A、B，如果集合B中任意一个元素都是集合A中的元素，我们就说这两个集合有包含关系，称集合A为集合B的超集(Superset) （ >= 真超集、 > 超集）

s.union(*others)：返回一个新集合，其内容是s集合与others容器的并集（注3)
注3:对于两个集合A、B，把他们所有的元素合并在一起组成的集合，叫做集合A与集合B的并集(Union).（ | 管道符）

s.intersection(*others)：返回一个新集合，其内容是s集合与others容器的交集(注4)
注4∶对于两个集合A、B，由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集（Intersection) .（ & and符）

s.difference(*others)：返回一个新集合，其内容是存在于s集合中，但不存在于others容器中的元素（注5)
注5:对于两个集合A、B，由所有属于集合A且不属于集合B的元素所组成的集合，叫做集合A与集合B的差集(Difference)。（ - 减号）

s.symmetric_difference(other)：返回一个新集合，其内容是排除掉s集合和other容器中共有的元素后，剩余的所有元素，即对称差集。（ ^ 脱字符）
注6: others参数表示支持多个容器（参数类型可以是集合，也可以是序列) ; other参数则表示单个容器。若使用括号中的运算符，则需要符号两边都为集合类型的数据。

3、仅适用于set()的方法

update(*others)：使用others参数指定的值来更新集合

intersection_update(*others)：使用交集的方式来更新集合
difference_update( *others)：使用差集的方式来更新集合
symmetric_difference_update(others)：使用对称差集的方式来更新集合
以上三个方法与上一点中的交集差集对称差集的区别在于，上一点是直接返回一个新的集合，而update是对原集合进行更新，在原集合上进行改动。

add(elem)：向集合中添加数据。当向集合中添加字符串时，使用update是迭代字符串中的每一个字符分别作为集合的元素，而add是将整个字符串作为一个元素插入。

>>> x = {1, 2, 3}
>>> x.update('love')
>>> x
{1, 2, 3, 'l', 'v', 'e', 'o'}
>>> x.add('123')
>>> x
{1, 2, 3, '123', 'l', 'v', 'e', 'o'}

remove(elem)、discard(elem)：删除集合中指定的元素，但不同的是remove方法在找不到指定的元素时会抛出异常，而discard则会静默处理。

pop()：随机从集合中集合中弹出一个元素

clear()：清空集合的所有元素

4、可哈希

想要正确的创建字典或者集合，那么则要求字典的键和集合元素是可哈希的

可哈希：如果一个对象是可哈希的，那么就要求他的哈希值必须在其整个生命周期中保持不变

不可变对象：可哈希。例如元组、集合等可变对象：不可哈希。例如列表等

hash(object)：获取对象的哈希值。
对整数求哈希值，其哈希值等于本身。
若两个对象的值是相等的，尽管是不同的对象，那么哈希值也是相等的。
只能对不可变的对象求哈希值，可变的对象不行。

十三、函数

1、创建和调用函数

>>> def myfunc():print('喊我干嘛')pass>>> myfunc()
喊我干嘛

2、函数的返回值，return语句

>>> def mul(x, y):return x*y>>> mul(2, 2)
4>>> def mul():pass>>> print(mul())
None

当执行到return语句时，函数将会返回，不会再执行之后的语句

若函数没有写return语句，那么在函数执行结束之后会默认返回一个None值

3、函数的参数

>>> def myfunc(name, times):for i in range(times):print(f'I love {name}')>>> myfunc('you', 3)
I love you
I love you
I love you

参数可以分为形式参数和实际参数，形参是定义函数时写的参数的名字，例如name，times，实参指调用函数时传进函数的参数值，例如‘you’和3

（1）位置参数

实参是按照形参定义的顺序进行传递的。

（2）关键字参数

知道参数的名字就可以使用关键字参数

若要同时使用位置参数以及关键字参数，则位置参数必须在关键字参数之前

>>> def func(x, z):print(x, '爱', z)>>> func('你', '我')
你 爱 我
>>> func(z = '你', x = '我')
我 爱 你>>> def ppp(x, y, z, a):print(x, y, z, a)>>> ppp(1, 2, 3, z = 5)
Traceback (most recent call last):File "<pyshell#49>", line 1, in <module>ppp(1, 2, 3, z = 5)
TypeError: ppp() got multiple values for argument 'z'
>>> ppp(1, 2, a = 3, z = 5)
1 2 5 3

（3）默认参数

函数在定义时为参数设定的值，若为传入实参，则使用默认参数，并且默认参数应该放置在所有参数的最后。

（4）' / '

在' / '左侧的参数必须传递位置参数，不能使用关键字参数。

>>> def aaa(a, /, b, c):print(a, b, c)>>> aaa(a = 1, 2, 3)
SyntaxError: positional argument follows keyword argument
>>> aaa(1, b = 2, c = 3)
1 2 3

（5）' * '

在' * '右侧的参数必须传递关键字参数，不能使用位置参数。

>>> def bbb(a, *, b, c):print(a, b, c)>>> bbb(1, 2, 3)
Traceback (most recent call last):File "<pyshell#63>", line 1, in <module>bbb(1, 2, 3)
TypeError: bbb() takes 1 positional argument but 3 were given
>>> bbb(1, b = 2, c = 3)
1 2 3

（6）收集参数

例如print()这种参数可多可少的函数。定义的时候在形参前面加上星号，传的参数在函数中是一个元组。

>>> def myfunc(*xs):print('传入了{}个参数'.format(len(xs)))print('第一个参数是{}'.format(xs[0]))print(xs)>>> myfunc(1, 2, 3, 4, 5)
传入了5个参数
第一个参数是1
(1, 2, 3, 4, 5)

元组的打包解包功能也可以用在函数中。若要函数返回多个值，就会使用元组进行打包。也可以对返回的值进行解包

>>> def a():return 1, 2, 3>>> a()
(1, 2, 3)
>>> x, y, z = a()
>>> print(x, y, z)
1 2 3

函数的收集参数就是使用该原理，通过使用' * '实现打包操作。

>>> def myfunc(*xs):return type(xs)>>> myfunc(1, 2, 3)
<class 'tuple'>

若在收集参数后还需要指定其他参数，在调用函数的时候则应该使用关键字参数进行传值，在第（5）点中的' * '号就是一个匿名的收集参数，因此它后面才不能使用位置参数。

>>> def myfunc(*xs, a, b):print(xs, a, b)>>> myfunc(1, 2, 3, 4, 5)
Traceback (most recent call last):File "<pyshell#22>", line 1, in <module>myfunc(1, 2, 3, 4, 5)
TypeError: myfunc() missing 2 required keyword-only arguments: 'a' and 'b'
>>> myfunc(1, 2, 3, a = 4, b = 5)
(1, 2, 3) 4 5

收集参数还可以将参数打包为字典，使用' ** '，同时必须使用关键字参数进行传值

>>> def myfunc(**keywords):print(keywords)>>> myfunc(a = 1, b = 2, c = 3)
{'a': 1, 'b': 2, 'c': 3}

将打包为元组的收集参数和打包为字典的收集参数混合起来进行使用，字符串的format()方法就是使用了这两种方法。

>>> def myfunc(a, *b, **c):print(a, b, c)>>> myfunc(1, 2, 3, 4, d = 5, e = 6, f = 7)
1 (2, 3, 4) {'d': 5, 'e': 6, 'f': 7}

（7）解包参数

收集参数中的' * '、' ** '不仅可以在函数定义的时候使用，还可以在函数调用的时候进行使用，在形参上称之为参数的打包，在实参上使用则是解包。两个星号对应的是关键字参数

>>> args = (1, 2, 3, 4)
>>> def pp(a, b, c, d):print(a, b, c, d)>>> pp(args)
Traceback (most recent call last):File "<pyshell#37>", line 1, in <module>pp(args)
TypeError: pp() missing 3 required positional arguments: 'b', 'c', and 'd'
>>> pp(*args)
1 2 3 4>>> keyargs = {'a':1, 'b':2, 'c':3, 'd':4}
>>> pp(**keyargs)
1 2 3 4

小甲鱼python入门笔记（二）相关推荐

小甲鱼python入门笔记（一）（全）
目录一.变量和字符串 1.python转义字符 2.交换x,y变量的值 3.原始字符串,忽略转义字符 4.长字符串两种方式 5.字符串加法和乘法二.是时候讲讲代码了 1.python比较运算符三 ...
小甲鱼python入门笔记（三）
目录十三.函数 4.作用域 (1)局部作用域 (2)全局作用域 (3)global语句 (4)嵌套函数 (5)nonlocal语句 (6)LEGB规则 5.闭包 6.装饰器 7.lambda表达式 ...
B站小甲鱼python学习笔记
000 愉快的开始视频地址: https://www.bilibili.com/video/BV1xs411Q799?p=1 python跨平台应用范围: 操作系统.WEB.3D动画.企业应用.云 ...
小甲鱼Python第二十二讲课后习题
笔记: 斐波那契数列的两种实现方式: 迭代的方式: 自己写的: def fab(n): n1 =1 n2 =1 n3 =1 if n < 1: return -1 if n ==1: retur ...
小甲鱼python入门_python基础笔记（非系统/自用/参考小甲鱼的零基础入门学习python）上...
---恢复内容开始--- 1.原始字符串的使用,在字符串前加r就行(用于对\进行自动转译) >>>str = r'C:\now\wifr' 'C:\\now\\wifr' 但在字符串 ...
小甲鱼python数字游戏给三次机会_【python 入门案例】小甲鱼python入门猜数字游戏...
一.猜数字--一次机会,无提示 print("--------------第一次尝试---------------") temp = input("猜一下小西几心里想的什 ...
小甲鱼Python学习笔记之魔法方法
什么是魔法方法构造和析构 __init__方法 __new__方法 __del__方法工厂函数通过对魔法方法的重写,还可以自定义对象间的算术运算反运算方法实现一个计时器的类 time模块的l ...
小甲鱼Python学习笔记之函数（三）
递归定义递归的两个特点(重中之重!!!) 递归的应用能够用递归实现的功能都能够用循环迭代来实现用递归实现斐波那契数列用其他方式实现斐波那契数列用递归实现汉诺塔定义函数之间是可以相互调用 ...
小甲鱼Python学习笔记之函数（四）
函数注释类型注释 Python自省函数注释通过help来查看函数的注释自定义函数时编写函数注释 >>> def exchang(dollar,rate=6.32):" ...

小甲鱼python入门笔记（二）

九、字符串

1、大小写字母换来换去

2、左中右对齐

3、实现字符串的查找功能

4、替换

5、字符串各种情况下的判断和检测

6、截取字符串

7、拆分和拼接

8、格式化字符串

9、f-字符串（f-string）

十、序列

1、能够作用于序列的运算符和函数

2、跟序列相关的一些函数

3、迭代器与可迭代对象

十一、字典

1、创建字典的六种方法

2、增，fromkeys()

3、删，pop()

4、改，update()

5、查，get()，setdefault()

6、字典的其他操作

7、嵌套

8、字典推导式

十二、集合

1、集合的三种创建方法

2、集合的各种内置方法

3、仅适用于set()的方法

4、可哈希

十三、函数

1、创建和调用函数

2、函数的返回值，return语句

3、函数的参数

（1）位置参数

（2）关键字参数

（3）默认参数

（4）' / '

（5）' * '

（6）收集参数

（7）解包参数

小甲鱼python入门笔记（二）相关推荐

最新文章

热门文章