[Python知识库]Python笔记

目录

1.函数参数
2.全局变量&局部变量
3.文件读写
4.数字
5.字符串
6.列表
7.元组
8.字典
9.集合
10.常用内置函数
11.math库
12.random库
.
.
.

在计算机语言中，有两种赋值方式：按引用赋值、按值赋值。
（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,否则返回 False
• str.isalpha():如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False。
• str.isdigit():如果字符串只包含数字则返回 True 否则返回 False。
• str.islower():如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
• str.isupper():如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
• str.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，则返回True
• bin():返回一个整数 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]

math库

import math

• ceil(x):返回 x 的上限，即大于或者等于 x 的最小整数。
• floor(x) :返回 x 的向下取整，小于或等于 x 的最大整数
• trunc(x):返回 Real 值 x 截断为 Integral
• gcd(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,默认底为 e
• log2(x):返回 x 以2为底的对数
• log10(x):返回 x 底为10的对数
• pow(x, y):返回x 的 y 次幂.与内置的 ** 运算符不同， math.pow() 将其参数转换为 float 类型
• sqrt(x):返回 x 的平方根
• factorial(x):以一个整数返回 x 的阶乘。 如果 x 不是整数或为负数时则将引发 ValueError
• copysign(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)。
  （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）服从指定分布的实数
…