在计算机语言中，有两种赋值方式：按引用赋值、按值赋值。
（1）引用赋值
a = 10000
b = a
b和a不仅在值上相等，而且是同一个对象，也就是说在堆内存中只有一个数据对象10000，这两个变量都指向这一个数据对象。从数据对象的角度上看，这个数据对象有两个引用，只有这两个引用都没了的时候，堆内存中的数据对象10000才会等待垃圾回收器回收。
- 对于可变对象，修改a的同时b也会变化
- 对于不可变对象，修改变量的值意味着在内存中要新创建一个数据对象
（2）按值赋值
a = 10000
b = 10000
虽然a和b的值相等，但他们不是同一个对象，这时候在堆内存中有两个数据对象，只不过这两个数据对象的值相等。
- 深拷贝&浅拷贝&赋值（深度剖析）
浅拷贝：shallow copy，只拷贝第一层的数据。python中赋值操作或copy模块的copy()就是浅拷贝
深拷贝：deep copy，递归拷贝所有层次的数据，python中copy模块的deepcopy()是深拷贝
函数参数
- 补充两种形式
（1）调用函数时指定（不清楚参数的顺序）
def demo(a ,b):
print(a)
print(b)
demo(b=1,a=5)
output
5
1
（2）默认值
def demo(x,a=3 ,b=4):
print(x)
print(a)
print(b)
demo(5)
output
5
3
4
- 注意没有默认值的参数要放在有定义值的前面
- 错误示例
- 正确示例
全局变量&局部变量
- 全局变量：定义在函数之外
- 局部变量：定义在函数之内
g_var = 1
def fun():
l_var = g_var
print(l_var)
print(g_var)
ps：函数内部不能定义全局变量，只能使用和改变全局变量，改变全局变量需要实现声明全局变量（在函数中定义的局部变量如果和全局变量同名，则它会隐藏该全局变量。所以如果想在函数中使用全局变量，则需要使用global进行声明。）
- demo1
x = 1
def func():
x = 2
print x
print x
func()
print x
1
2
1
- demo2
x = 1
def func():
global x
print x
x = 2
print x
print x
func()
print x
1
1
2
2
文件读写
- 使用open()会返回一个file对象
my_file = open(file_name,mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。
- 读文件
my_file.read(size)
读取一定数目的数据, 然后作为字符串或字节对象（二进制读取）返回。
size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
#关闭打开的文件
f.close()
Python 是一个非常好的语言。
是的，的确非常好!!
my_file.readline()
从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行
f = open("/tmp/foo.txt", "r")
str = f.readline()
print(str)
f.close()
Python 是一个非常好的语言。
my_file.readlines()
返回该文件中包含的所有行的列表
f = open("/tmp/foo.txt", "r")
str = f.readlines()
print(str)
f.close()
['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']
for line in my_file:
迭代一个文件对象然后读取每行
f = open("/tmp/foo.txt", "r")
for line in f:
print(line, end='')
# 关闭打开的文件
f.close()
Python 是一个非常好的语言。
是的，的确非常好!!
- 写文件
f.write(string)
将 string 写入到文件中, 然后返回写入的字符数
f = open("/tmp/foo.txt", "w")
num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
print(num)
f.close()
29
注意：如果要写入一些不是字符串的东西, 那么将需要先进行转换
f = open("/tmp/foo1.txt", "w")
value = ('www.runoob.com', 14)
s = str(value)
f.write(s)
f.close()
('www.runoob.com', 14)
Python有6中标准数据类型：数字、字符串、列表、元组、字典、集合
- 不可变数据类型：数字、字符串、元组
- 可变数据类型：列表、字典、集合
数字
int、float、bool、complex
type()用于查询数据类型
a = 3
print(type(a))
- 可以同时为多个变量赋值
a,b = 1,'hello'
（1）数字运算
可以自己处理加减乘数优先级
/返回结果为浮点数的除法//丢弃结果的小数部分，但是返回的数据类型与分子和分母有关，当分子或分母有float类型，则结果为float类型
17/3 #5.666667
17//3 #5
17.0//3 #5.0
17/3.0 #5.0
- 幂运算
**
2**5 #32
- 不同类型的数进行运算时，会将整数转换为浮点数
3 * 3.75 / 1.5 #7.5
- 在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
（2）类型转换
int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
a = 1.0
int(a) #1
（3）数学函数
abs(x):返回绝对值或大小divmod(x, y):返回(x // y, x % y)round(x [,n]):返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。（但是在机器中浮点数不一定能精确表达）max(x,y,z):返回给定参数的最大值，参数可以为序列。(当参数是序列时，返回的是排序最大的那个序列;True在比较中视为1，False视为0)且入参类型不能混入（要么全Number(int|float|complex|bool），要么全序列，若为全序列则类型要一致）。min(x,y,z):返回给定参数的最小值，参数可以为序列。
max((1,-1,0), (True,False,2,0),(1, 0, 0, 2))
# (True, False, 2, 0)
max([1,3,2],3,4) #非法入参
# TypeError: '>' not supported between instances of 'int' and 'list'
max((1,2,3), [2,4,1]) #非法入参
# TypeError: '>' not supported between instances of 'list' and 'tuple'
字符串
（1）简单介绍
！ 使用引号( ’ 或 " )来创建字符串
！Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
！不可变对象
- 可以使用方括号 [] 来截取字符串
var1 = 'Hello World!'
var2 = "Runoob"
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
# var1[0]: H
# var2[1:5]: unoo
（2）字符串运算
a = 'Hello'
b = 'Python'
+:字符串连接
a+b
# HelloPython
*:重复输出字符串
a*2
# HelloHello
[]:通过索引获取字符串中字符
a[1]
# e
[ : ]:截取字符串中的一部分，遵循左闭右开原则
a[1:4]
# ell
in:成员运算符 - 如果字符串中包含给定的字符返回 True
'H' in a
# True
not in:成员运算符 - 如果字符串中不包含给定的字符返回 True
'M' not in a
# True
r/R: 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法
print( r'\n' )
# \n
（3）常用内建函数
string是不可变对象，因此调用函数并没有改变原字符串的内容，而是在原字符串的基础上新建了一个字符串返回
len( str ):返回str长度str.capitalize():将字符串的第一个字符转换为大写str.count(sub, start= 0,end=len(string)):用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
str="www.runoob.com"
str.count('run',0,10) #1
str.find(str, beg=0, end=len(string)):检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
str1 = "Runoob example....wow!!!"
print (str1.find('exam', 5)) # 7
print (str1.find('exam', 10)) # -1
str.rfind(str, beg=0,end=len(string)):类似于 find()函数，不过是从右边开始查找.str.index(str, beg=0, end=len(string)):find()方法一样，只不过如果str不在 string中会报一个异常str.rindex( str, beg=0, end=len(string)):类似于 index()，不过是从右边开始.str.replace(old, new[, max]):把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
old – 将被替换的子字符串。
new – 新字符串，用于替换old子字符串。
max – 可选字符串, 替换不超过 max 次
s = 'helldjlldhhhlllo'
print(s.replace('l','*',3))
# he**dj*ldhhhlllo
str.strip([chars]):用于移除字符串头尾指定的字符（默认为空格）或字符序列.该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
str = "*****this is **string** example....wow!!!*****"
print (str.strip( '*' )) # 指定字符串 *
# this is **string** example....wow!!!
str.lstrip([chars]):用于截掉字符串左边的空格或指定字符str.rstrip([chars]):用于截掉字符串右边的空格或指定字符str.split(str="", num=string.count(str)):通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。默认为 -1, 即分隔所有。
str = "this is string example....wow!!!"
print (str.split( )) # 以空格为分隔符
print (str.split('i',1)) # 以 i 为分隔符
print (str.split('w')) # 以 w 为分隔符
# ['this', 'is', 'string', 'example....wow!!!']
# ['th', 's is string example....wow!!!']
# ['this is string example....', 'o', '!!!']
str.join(sequence):将序列中的元素以指定的字符连接生成一个新的字符串。函数中的 sequence 中的元素必须的字符串，否则会报错。
s1 = "-"
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))
# r-u-n-o-o-b
str.title():返回"标题化"的字符串,就是说所有单词的首个字母转化为大写str.upper():将字符串中的小写字母转为大写字母str.lower():转换字符串中所有大写字符为小写。max(str):返回字符串中最大的字母min(str):返回字符串中最小的字母str.encode(encoding='UTF-8',errors='strict'):以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案
encoding – 要使用的编码，如: UTF-8。
errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。
str = "菜鸟教程";
str_utf8 = str.encode("UTF-8")
# b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'
str_gbk = str.encode("GBK")
# b'\xb2\xcb\xc4\xf1\xbd\xcc\xb3\xcc'
bytes.decode(encoding="utf-8", errors="strict"):以指定的编码格式解码 bytes 对象。默认编码为 ‘utf-8’。
str_utf8.decode('UTF-8','strict')
# 菜鸟教程
str_gbk.decode('GBK','strict')
# 菜鸟教程
str.isalnum():如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 Falsestr.isalpha():如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False。str.isdigit():如果字符串只包含数字则返回 True 否则返回 False。str.islower():如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 Falsestr.isupper():如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 Falsestr.isspace():如果字符串中只包含空格，则返回 True，否则返回 False.str.istitle():如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.
（4）格式化字符串
str.format():格式化字符串
# 不设置指定位置，按默认顺序
"{} {}".format("hello", "world")
# 'hello world'
# 设置指定位置
"{1} {0} {1}".format("hello", "world")
# 'world hello world'
数字格式化
print("{:.2f}".format(3.1415926))
# 3.14
print("{:.2%}".format(0.25))
# 25.00%
以及对齐方式，带符号、补零、进制表示等
- 类似C中的语法
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
f-string:称之为字面量格式化字符串，是新的格式化字符串的语法
f'{1+2}'
# 3
name = 'Runoob'
f'Hello {name}' # 替换变量
# 'Hello Runoob'
x = 1
print(f'{x+1}') # Python 3.6
# 2
（5）转义字符
\(在行尾时）：续行符
print("line1 \
... line2 \
... line3")
# line1 line2 line3
\\:反斜杠符号
print("\\")
# \
':单引号
print("\'")
# '
\":双引号
print("\"")
# "
\b":退格(Backspace)
print("Hello \b World!")
# Hello World!
\n: 换行
print("\n")
列表
列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或
所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系，可以是不同类型的元素。
鉴于列表通常包含多个元素，给列表指定一个表示复数的名称（如letters、digits或names）是
个不错的主意。
（1）创建列表
在Python中，用方括号（[]）来表示列表，并用逗号来分隔其中的元素。
bicycles = ['trek', 'cannondale', 'redline', 'specialized']
（2）访问列表
[index]索引
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推；可以是负值，表示从后往前索引。通过索引列表可以进行截取、组合等操作。
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[1] )
# green
print( list[-1] )
# black
[:]:截取字符（左闭右开）
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
list[1:-2] # ['Runoob', 'Zhihu']
list[1:3] #['Runoob', "Zhihu"]
（3）更新列表
list[index]=new_item：修改列表
list = ['Google', 'Runoob', 1997, 2000]
list[2] = 2020
list # ['Google', 'Runoob', 2020, 2000]
list.append(obj):添加列表项del list[i]：删除列表项
del list[2]
# ['Google', 'Runoob', 2000]
（4）列表操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
squares = [1, 4, 9, 16, 25]
squares += [36, 49, 64, 81, 100]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
（5）嵌套列表
列表中的项为列表
a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
x # [['a', 'b', 'c'], [1, 2, 3]]
x[0] # ['a', 'b', 'c']
x[0][1] #'b'
（6）常用函数
len(list)max(list)min(list)list(seq)
（7）常用方法list.append(obj):在列表末尾添加新的对象
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
# ['Google', 'Runoob', 'Taobao', 'Baidu']
list.count(obj):统计某个元素在列表中出现的次数。
aList = [123, 'Google', 'Runoob', 'Taobao', 123];
aList.count(123) #2
list.extend(seq):用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
# 列表
language = ['French', 'English', 'German']
# 元组
language_tuple = ('Spanish', 'Portuguese')
# 集合
language_set = {'Chinese', 'Japanese'}
language.extend(language_tuple)
# ['French', 'English', 'German', 'Spanish', 'Portuguese']
language.extend(language_set)
# ['French', 'English', 'German', 'Spanish', 'Portuguese', 'Chinese', 'Japanese']
list.index(x[, start[, end]]):用于从列表中找出某个值第一个匹配项的索引位置。如果没有找到对象则抛出异常。
x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。
list1 = ['Google', 'Runoob', 'Taobao', 'Facebook', 'QQ']
list1.index('Taobao') # 2
list1.index('Runoob',1) #1
list.insert(index, obj):用于将指定对象插入列表的指定位置。
list1 = ['Google', 'Runoob', 'Taobao']
list1.insert(1, 'Baidu')
# ['Google', 'Baidu', 'Runoob', 'Taobao']
list.pop([index=-1]):用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。list.remove(obj):用于移除列表中某个值的第一个匹配项。
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.remove('Taobao')
# ['Google', 'Runoob', 'Baidu']
list.reverse():用于反向列表中元素。list.sort( key=None, reverse=False):用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
aList.sort() #升序
aList.sort(reverse=True) #按降序排列
# ['Facebook', 'Google', 'Runoob', 'Taobao']
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
# 输出类别
print (random)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
list.clear():用于清空列表，类似于 del a[:]list.copy():用于复制列表，类似于 a[:]。
元组
! 列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，
! 元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
! 元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来
访问其元素，就像访问列表元素一样。
（1）创建元组
注意：元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
# 创建空元组
tup1 = ()
tup2 = ('Google', 'Runoob', 1997, 2000)
tup3 = (50,)
（2）访问元组（与list类似，索引，截取）
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
tup1[0] # Google
tup2[1:5] # (2, 3, 4, 5)
（3）组合元组（元组不可修改）
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2 # (12, 34.56, 'abc', 'xyz')
（4）删除整个元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。
tup = ('Google', 'Runoob', 1997, 2000)
del tup
（5）元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
+ * in for
（6）内置函数len(tuple) 、min(tuple) 、max(tuple) 、tuple(iterable)
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1) # ('Google', 'Taobao', 'Runoob', 'Baidu')
字典
! 字典是另一种可变容器模型，且可存储任意类型对象。
! 字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会将前一个覆盖
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
dict['Name'] # '小菜鸟'
- 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。
（1）创建字典
- 格式：
d = {key1 : value1, key2 : value2, key3 : value3 }
# 创建空字典
emptyDict = {}
dict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
dict():重建字典
emptyDict = dict()
（2）访问字典
如果用字典里没有的键访问数据，会输出错误
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Name'] # Runoob
dict['Alice'] # KeyError: 'Alice'
（3）修改字典
- 添加/修改指定key对应的value
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # 更新 Age
dict['School'] = "XMU" # 添加信息
- 删除
del dict['Name']
dict.clear() # 清空字典
del dict # 删除字典
（4）内置函数&&方法
- 内置函数：
len()， str()， type() dict.clear():用于删除字典内所有元素dict.copy():返回一个字典的浅复制。
dict1 = {'user':'runoob','num':[1,2,3]}
dict2 = dict1 # 浅拷贝: 引用对象
dict3 = dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用
dict1['user']='root'
dict1['num'].remove(1)
# 输出结果
print(dict1) # {'user': 'root', 'num': [2, 3]}
print(dict2) # {'user': 'root', 'num': [2, 3]}
print(dict3) # {'user': 'runoob', 'num': [2, 3]}
dict.fromkeys(seq[, value]):用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
seq – 字典键值列表。
value – 可选参数, 设置键序列（seq）对应的值，默认为 None。
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
# {'age': None, 'name': None, 'sex': None}
dict = dict.fromkeys(seq, 10)
# {'age': 10, 'name': 10, 'sex': 10}
dict.get(key, default=None):返回指定键的值，如果键不在字典中返回默认值 None 或者指定的默认值。
dict = {'Name': 'Runoob', 'Age': 27}
dict.get('Age') # 27
dict.get('Sex', "NA") #NA
key in dict:字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。
'Age' in dict # True
dict.items():字典 items() 方法以列表返回视图对象（只读），是一个可遍历的key/value 对。此示例显示视图的动态特性：keys视图不是给定时间点的键的副本，而是一个显示键的简单窗口；如果键被更改，则通过窗口看到的内容也会更改。
dict = {'Name': 'Runoob', 'Age': 7}
dict.items()
# dict_items([('Age', 7), ('Name', 'Runoob')])
dict = {'Name': 'Runoob', 'Age': 7}
for i,j in dict.items():
print(i, ":\t", j)
# Name : Runoob
# Age : 7
dict.keys():返回一个视图对象。dict.values():返回一个视图对象。
dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
keys = dishes.keys()
values = dishes.values()
# 迭代
n = 0
for val in values:
n += val
print(n)
# 504
# keys 和 values 以相同顺序（插入顺序）进行迭代
list(keys) # 使用 list() 转换为列表
['eggs', 'sausage', 'bacon', 'spam']
list(values)
# [2, 1, 1, 500]
# 视图对象是动态的，受字典变化的影响，以下删除了字典的 key，视图对象转为列表后也跟着变化
del dishes['eggs']
del dishes['sausage']
list(keys)
# ['bacon', 'spam']
dict.setdefault(key, default=None):和 get()方法 类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。
如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。
关于字典中 get() 和 setdefault() 的区别：主要在于当查找的键值 key 不存在的时候，setdefault()函数会返回默认值并更新字典，添加键值；而 get() 函数只返回默认值，并不改变原字典。
dict = {'Name': 'Runoob', 'Age': 7}
dict.setdefault('Age', None) # 7
dict.setdefault('Sex', None) # None
dict # {'Age': 7, 'Name': 'Runoob', 'Sex': None}
dict.update(dict2):把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里
dict = {'Name': 'Runoob', 'Age': 7}
dict2 = {'Sex': 'female' }
dict.update(dict2)
dict # {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}
pop(key[,default]):删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。如果没有 key，返回 default 值
如果要删除的 key 不存在，也没有设置默认值，会报错
>>> dict1 = {1: "a", 2: [1, 2]};
>>> print(dict1.pop(1),dict1);
a {2: [1, 2]}
>>> print(dict1.pop(3,"nokey"),dict1); # 设置默认值，必须添加，否则报错
nokey {2: [1, 2]}
>>> print(dict1.pop(3),dict1);
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 3
dict.popitem():返回并删除字典中的最后一对键和值。
集合
集合（set）是一个无序的不重复元素序列。
（1）创建集合
可以使用大括号 { } 或者 set() 函数创建集合
！注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
# 会自动去重
（2）添加元素
s.add( x ):将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
# {'Taobao', 'Facebook', 'Google', 'Runoob'}
s.update( x ):参数可以是列表，元组，字典等
thisset = set(("Google", "Runoob", "Taobao"))
thisset.update({1,3})
print(thisset)
# {1, 3, 'Google', 'Taobao', 'Runoob'}
thisset.update([1,4],[5,6])
print(thisset)
# {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
（3）移除元素
s.remove( x ):将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao")
print(thisset)
# {'Google', 'Runoob'}
thisset.remove("Facebook") # 不存在会发生错误
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# KeyError: 'Facebook'
s.discard( x ):也是移除集合中的元素，且如果元素不存在，不会发生错误
thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook") # 不存在不会发生错误
print(thisset)
{'Taobao', 'Google', 'Runoob'}
s.pop():随机删除集合中的一个元素.set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x) # Runoob
（4）清空集合
s.clear()
（5）判断元素是否存在
x in s
thisset = set(("Google", "Runoob", "Taobao"))
"Runoob" in thisset
# True
（6）集合运算
- 交集
& - 并集
| - 差集
- - 对称差
^
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}
- 集合推导式（类似于列表推导式）
a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
（7）其他内置函数
set.copy():用于拷贝一个集合。
fruits = {"apple", "banana", "cherry"}
x = fruits.copy()
# {'cherry', 'banana', 'apple'}
set.intersection(set1[, set2 ... etc]):用于返回两个或更多集合中都包含的元素，即交集。返回一个新的集合。
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
result = x.intersection(y, z)
print(result)
# {'c'}
set.intersection_update(set1[, set2 ... etc]):intersection_update() 方法用于获取两个或更多集合中都重叠的元素，即计算交集。
intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
x.intersection_update(y, z)
print(x)
# {'c'}
set.difference(set):用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)
# {'cherry', 'banana'}
set.difference_update(set):用于移除两个集合中都存在的元素。difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.difference_update(y)
print(x)
# {'cherry', 'banana'}
set.symmetric_difference(set):返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。返回一个新的集合。
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.symmetric_difference(y)
print(z)
# {'google', 'cherry', 'banana', 'runoob'}
set.symmetric_difference_update(set):移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.symmetric_difference_update(y)
print(x)
# {'google', 'cherry', 'banana', 'runoob'}
set.union(set1 [, set2...]):返回两个或多个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。
x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"}
result = x.union(y, z)
print(result)
# {'c', 'd', 'f', 'e', 'b', 'a'}
set.isdisjoint(set):两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}
z = x.isdisjoint(y) # True
set1.issubset(set2):判断集合set1是否为set2的子集。如果是则返回 True，否则返回 False。set1.issuperset(set2):判断set1是是否包含set2，如果是则返回 True，否则返回 False。
常用内置函数
abs():返回数字的绝对值all():判断给定的参数中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。any():有一个为True，则返回Truebin():返回一个整数 int 或者长整数 long int 的二进制表示
bin(10)
# '0b1010'
chr(i):用一个整数i作参数，返回一个对应的字符。i – 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。返回值是当前整数对应的 ASCII 字符。
chr(97)
# 'a'
hex(i):用于将一个指定数字i转换为 16 进制数
hex(255)
# '0xff'
oct(i):将一个整数转换成 8 进制字符串，8 进制以 0o 作为前缀表示。
类型转换
bool(x):用于将给定参数转换为布尔类型，如果没有参数，返回 False。bool 是 int 的子类int(x, base=10):将一个字符串或数字转换为整型。x – 字符串或数字；base – 进制数，默认十进制。
int(3.6) # 3
int('12',16) #18
int('0xa',16) #10
float(x):函数用于将整数和字符串转换成浮点数str(object, encoding=encoding, errors=errors):将指定的值转换为字符串。
object 任何对象。规定要转换为字符串的对象。
encoding 对象的编码。默认是 UTF-8。
errors 规定解码失败时该怎么办list( seq ):用于将元组或字符串转换为列表
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)
# 列表元素 : [123, 'Google', 'Runoob', 'Taobao']
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
# 列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
set([iterable]):创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
x = set('runoob')
# set(['b', 'r', 'u', 'o', 'n']
tuple( iterable ):将可迭代系列（如列表）转换为元组
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)
# ('Google', 'Taobao', 'Runoob', 'Baidu')
其他
len( s ):返回对象（字符、列表、元组等）长度或项目个数
str = "runoob"
len(str)
# 6
range([start,] stop[, step]):返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
list(range(0, 30, 5))
# [0, 5, 10, 15, 20, 25]
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False):用于打印输出
objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep – 用来间隔多个对象，默认值是一个空格。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file – 要写入的文件对象。
flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
print("Hello World")
# Hello World
print("aaa","bbb")
# aaa bbb
print("www","runoob","com",sep=".")
# www.runoob.com
import time
print("---RUNOOB EXAMPLE ： Loading 效果---")
print("Loading",end = "")
for i in range(20):
print(".",end = '',flush = True)
time.sleep(0.5)
# 动态效果图
eval(expression[, globals[, locals]]):用来执行一个字符串表达式，并返回表达式的值。
x = 7
eval( '3 * x' )
21
str.format():格式化字符串
# 不设置指定位置，按默认顺序
"{} {}".format("hello", "world")
# 'hello world'
# 设置指定位置
"{1} {0} {1}".format("hello", "world")
# 'world hello world'
数字格式化
print("{:.2f}".format(3.1415926))
# 3.14
print("{:.2%}".format(0.25))
# 25.00%
以及对齐方式，带符号、补零、进制表示等
input([prompt]):接受一个标准输入数据，返回为 string 类型
a = input('please input')
type(object):返回对象类型slice([start,] stop[, step]):实现切片对象，主要用在切片操作函数里的参数传递
start – 起始位置
stop – 结束位置
step – 间距
a = ("a", "b", "c", "d", "e", "f", "g", "h")
x = slice(2)
print(a[x])
# ('a','b')
sorted(iterable, key=None, reverse=False):注意区别list.sort()。sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
iterable – 可迭代对象。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
# 默认为升序
sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]
# 要进行反向排序，也通过传入第三个参数 reverse=True：
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
sorted(example_list, reverse=True)
# [7, 6, 5, 4, 3, 2, 1, 0]
# 利用key进行倒序排序
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]
# 先按照成绩降序排序，相同成绩的按照名字升序排序：
d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
l = sorted(d1, key=lambda x:(-x['score'], x['name']))
sum(iterable[, start]):对序列进行求和计算
iterable – 可迭代对象，如：列表、元组、集合。
start – 指定相加的参数，如果没有设置这个值，默认为0
sum([0,1,2]) #3
sum([0,1,2,3,4], 2) # 列表计算总和后再加 2
# 12
enumerate(sequence, [start=0]):用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
sequence – 一个序列、迭代器或其他支持迭代对象。
start – 下标起始位置
返回 enumerate(枚举) 对象
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1)) # 小标从 1 开始
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, element)
# 0 one
# 1 two
# 2 three
filter(function, iterable):用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
function – 判断函数。
iterable – 可迭代对象。
# 过滤出列表中的所有奇数：
def is_odd(n):
return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
# [1, 3, 5, 7, 9]
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
关于上述数据结构总结
- 列表是有序序列，其元素可以通过下标访问，元素可以是不同类型。其创建通过
[]符号，列表内元素通过,分隔； - 元组是不可改变的列表，除了其元素不能改变以外，其他几乎与列表一致，例如可以索引，合并切片等。其创建通过
()符号。 - 字典也是有序的，通过key访问其对应的value。其创建通过
{},例如{key1:value1, key2:value2, ...}。注意{}表示空字典。 - 集合是无序的不重复的元素的集合。其创建通过也通过
{}，但是为了区分字典，空集合必须使用set()创建。
math库
import math
ceil(x):返回 x 的上限，即大于或者等于 x 的最小整数。floor(x):返回 x 的向下取整，小于或等于 x 的最大整数trunc(x):返回 Real 值 x 截断为 Integralgcd(a, b):返回整数 a 和 b 的最大公约数。如果 a 或 b 之一非零，则 gcd(a, b) 的值是能同时整除 a 和 b 的最大正整数。gcd(0, 0) 返回 0.fabs(x):返回数字的绝对值，返回值为浮点型exp(x):返回 e 次 x 幂log(x[, base]):返回给定的 base 的对数 x,默认底为 elog2(x):返回 x 以2为底的对数log10(x):返回 x 底为10的对数pow(x, y):返回x 的 y 次幂.与内置的 ** 运算符不同， math.pow() 将其参数转换为 float 类型sqrt(x):返回 x 的平方根factorial(x):以一个整数返回 x 的阶乘。 如果 x 不是整数或为负数时则将引发 ValueErrorcopysign(x, y):返回一个基于 x 的绝对值和 y 的符号的浮点数
三角函数
角度转换
双曲函数
统计类函数
常量math.pi:数学常数 π = 3.141592…math.e:数学常数 e = 2.718281…
random库
import random
（1）整数随机数
randrange ([start,] stop [,step]):从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1。start – 指定范围内的开始值，包含在范围内。stop – 指定范围内的结束值，不包含在范围内。step – 指定递增基数。
# 从 0-99 选取一个随机数
random.randrange(100)
# 从 1-100 中选取一个奇数
random.randrange(1, 100, 2)
randrange(0,100, 2) # 从0-100中随机选取一个偶数
randrange(0,100, 4) # 从0-100中随机选取一个能被4整除的整数
randrange(1,100, 3) # 从0-100中随机选取一个能被3整除后余1的数
randint(a, b):返回随机整数 N 满足 a <= N <= b。相当于 randrange(a, b+1)。且必须指定两个参数a和b。
（2）序列随机数choice(seq):从非空序列 seq 返回一个随机元素。 如果 seq 为空，则引发 IndexError。seq可以是一个列表，元组或字符串。
random.choice(range(100)))
# 68
random.choice([1, 2, 3, 5, 9])
# 2
random.choice('Runoob')
# u
choices(population, weights=None,, cum_weights=None, k=1):从population中选择替换，返回大小为 k 的元素列表。 如果 population 为空，则引发 IndexError。
如果指定了 weight 序列，则根据相对权重进行选择。 或者，如果给出 cum_weights 序列，则根据累积权重（可能使用 itertools.accumulate() 计算）进行选择。 例如，相对权重[10, 5, 30, 5]相当于累积权重[10, 15, 45, 50]。 在内部，相对权重在进行选择之前会转换为累积权重，因此提供累积权重可以节省工作量。
如果既未指定 weight 也未指定 cum_weights ，则以相等的概率进行选择。 如果提供了权重序列，则它必须与 population 序列的长度相同。 一个 TypeError 指定了 weights 和cum_weights*。
weights 或 cum_weights 可以使用任何与 random() 返回的 float 值互操作的数值类型（包括整数，浮点数和分数但不包括十进制小数）。
对于给定的种子，具有相等加权的 choices() 函数通常产生与重复调用 choice() 不同的序列。 choices() 使用的算法使用浮点运算来实现内部一致性和速度。 choice() 使用的算法默认为重复选择的整数运算，以避免因舍入误差引起的小偏差。
random.choices(['red', 'black', 'green'], [18, 18, 2], k=6)
#['red', 'green', 'black', 'black', 'red', 'black']
shuffle(seq):将序列的所有元素随机排序
list = [20, 16, 10, 5];
random.shuffle(list)
print ("随机排序列表 : ", list)
# [20, 5, 16, 10]
注意，要改变一个不可变的序列并返回一个新的打乱列表，请使用sample(x, k=len(x))
sample(seq, k):返回一个列表，其中包含从序列中随机选择的指定数量的项目，此方法不会更改原始序列。（官方：返回从总体序列或集合中选择的唯一元素的 k 长度列表。 用于无重复的随机抽样。返回包含来自总体的元素的新列表，同时保持原始总体不变。 结果列表按选择顺序排列。）
random.sample([10, 20, 30, 40, 50], k=4)
#[40, 10, 50, 30]
（3）实数随机数
random():返回随机生成的一个实数，它在[0,1)范围内。
random.random()
#0.09690599908884856
# 实现 100-120 随机小数
(random.random()*21)+100
uniform(a, b):返回一个随机浮点数 N ，当 a <= b 时 a <= N <= b ，当 b < a 时 b <= N <= a.
random.uniform(5, 10)
# 7.054602800254241
random.uniform(2.5, 10.0)
# 3.1800146073117523
（4）服从指定分布的实数
…
1635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
