raw字符串(\不表示文中'的作用）

换行，制表符，强调即本身，转义（转义字符，字符串中的歧义）

布尔类型？？？？？？

取模运算%，地板除//，小数点位数round

整数，浮点数，字符串，布尔数（and,or,not）,空值none

可变参数即任意个参数的意思，可变参数通常使用*args来表示。

任意个数的平均值：

def average(*args):
   sum = 0 

   for item in args:
       sum += item
   avg = sum / len(args)
   return avg

对于可变关键字参数，一般使用**kwargs来表示。

def info(**kwargs):
   print('name: {}, gender: {}, age: {}'.format(kwargs.get('name'), kwargs.get('gender'), kwargs.get('age')))

info(name = 'Alice', gender = 'girl', age = 16)

isinstance()函数，判断参数类型

isinstance(100.0, int) # ==> False

Python递归函数

如果在一个函数内部调用其自身，这个函数就是递归函数。

def fact(n):
   if n==1:
       return 1
   return n * fact(n - 1)
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试计算 fact(10000)。

求出1~100的和：

def my_sumB(n):
   sum = 0
   if n == 1:
       sum = n
   else:
       sum = n + my_sumB(n - 1)
   return sum

def make_juice(fruit):

  print('将' + fruit + '去皮')

  print('将' + fruit + '切块')

定义函数   函数体

make_juice(“桃子”)   调用函数，参数（形参：fruit，实参：桃子），

return 语句是函数执行结束的标记，一般都要把 return 语句放在最后

参数分为：位置参数，关键字参数

按照 参数名 = 值 的格式传入了参数，这种参数就叫作 关键字参数

record(age=5, weight=21, name='佐藤正男', height=109)

Python 在解析参数时，是优先考虑 位置参数

record('佐藤正男', age=5, height=109, weight=21)

 默认参数 ：默认参数的要求是一定要放在非默认参数的后面，否则程序会出现错误，

def record(name, height, weight, age=5):

record('阿呆', 115, 25)

record('樱田妮妮', 105, 18, 4)

全局变量 在当前写的代码中一直起作用。全局变量 有效的范围，叫作 全局作用域。

需要在函数内部局部变量前加上 global 关键字，把局部变量强制变

Python 操作set的其他方法

remove()方法删除元素，元素不存在，报错。

discard()方法删除元素，元素不存在，不报错。

清除所有元素的方法clear()

集合的子集和超集

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
# 判断s1是否为s2的子集
s1.issubset(s2) # ==> True
# 判断s2是否为s1的超集
s2.issuperset(s1) # ==> True

判断集合是否重合

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
s1.isdisjoint(s2) # ==> False，因为有重复元素1、2、3、4、5

已知两个集合s1、s2，请判断两个集合是否有重合，如果有，请把重合的元素打印出来。

s1 = set([1, 2, 3, 4, 6, 8, 10])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
flag = s1.isdisjoint(s2)
if not flag:
   for item in s1:
       if item not in s2:
           continue
       print(item)

Python删除set元素

set提供了remove()方法允许我们删除set中的元素。如果remove的元素不在set里面的话，那么将会引发错误。

Python添加set元素

单独添加

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)
name_set.add('Gina')
print(name_set) # ==> set(['Gina', 'Alice', 'Candy', 'David', 'Ellena', 'Bob'])

批量添加

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
new_names = ['Hally', 'Isen', 'Jenny', 'Karl']
name_set = set(names)
name_set.update(new_names) # ==> set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
print(name_set)

读取set元素

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)

'Alice' in name_set # ==> True
set元素是区分大小写的

什么是set集合

set和list类似，拥有一系列元素，但是set和list不一样，set里面的元素是不允许重复的，而list里面可以包含相同的元素；set与list的另一个区别是，set里面的元素是没有顺序的。

s = set([1, 4, 3, 2, 5, 4, 2, 3, 1])
print(s) # ==> set([1, 2, 3, 4, 5])

获取dict的所有key

dict提供keys()函数，可以返回dict中所有的key。for key in d.keys():

获取dict所有的value

dict提供values()函数，可以返回dict中所有的value。for key in d.values():

清除所有元素

dict提供clear()函数，可以直接清除dict中所有的元素。

d.clear()  

print(d) # ==> {}

任务：输出字典元素数

d = {'Alice': [50, 61, 66], 'Candy': [88, 75, 90]}

keys = d.keys()
print(len(keys))  #len（）计数函数

任务：请把每个同学的每次成绩依次输出。方法2

# Enter a code

d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}

 for key in d:

...     value=d[key]

...     for score in value:

...        print(key,score)

Python dict的特点

比list查找速度快，占用内存大，完全key和value一致，但是无序。可以不重复

key不可变，tuple可做key，比如：

key = (1, 2, 3) # 以tuple作为key
d[key] = True
key = [1, 2, 3]
d[key] = True
# 报错

条件遍历，如成绩超过60的，在这种情况下，我们需要则需要遍历dict（这种时候需要使用for循环）：

 第一种是遍历dict的所有key，并通过key获得对应的value。

d = {
   'Alice': 45,
   'Bob': 60,
   'Candy': 75,
   'David': 86,
   'Ellena': 49
}
for key in d: # 遍历d的key
   value = d[key]
   if value > 60:
       print(key, value)
# ==> Candy 75
# ==> David 86

第二种方法是通过dict提供的items()方法，items()方法会返回dict中所有的元素，每个元素包含key和value。

for key, value in d.items():
   if value > 60:
       print(key, value)
# ==> Candy 75
# ==> David 86

任务：请把每个同学的每次成绩依次输出。

d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
for key, value in d.items():
   for score in value:
       print(key, score)

在dict中，使用keys()方法，可以返回dict的所有key，在删除某个元素时，可以通过这个方法先判断某个元素是否存在，

d = {
   'Alice': 45,
   'Bob': 60,
   'Candy': 75,
   'David': 86,
   'Ellena': 49
}
name = 'Alice'
if name in d.keys():
   d.pop(name)
else:
   print('{} not in d'.format(name))

Python更新dict元素

d['Bob'] = 75
当key不存在时，往dict中添加对应的key: value元素。

当key存在时，会更新dict，用新的value替换原来的value。

因此，在使用赋值语句往dict中添加元素时，为了避免不必要的覆盖问题，我们需要先判断key是否存在，然后再做更新。d.get('Alice')不会报错。

添加dict元素

d = {   'Alice':[45],   'Bob': 60}

d['Alice'].append(75)  #Alice对应的value值是列表

print(d)#{'Alice': [45, 75], 'Bob': 60}

d['Mimi'] = [72, 73]

print(d)#{'Alice': [45, 75], 'Bob': 60, 'Mimi': [72, 73]}

读取dict元素

方法一

d = {'Alice': 45,   'Gaven': 86}

print(d['Alice']) # ==> 45

print(d['Dodo'])# 抛出异常，字典里没有Dodo

if 'Alice' in d:
   print(d['Alice']) # ==> 45  #以避免错误。

if 'Dodo' in d: # Dodo不存在，所以不会走下面的逻辑
   print(d['Dodo'])
方法二

把key当作参数传递给get方法，就可以获取对应的value，当key不存在时，也不会报错，而是返回None。

print(d.get('Alice')) # ==> 45
print(d.get('Dodo')) # ==> None
因此更加推荐使用get方法来获取dict的元素。

什么是dict字典

我们使用花括号{}表示这是一个dict，

然后key和value之间使用冒号:分割，

并且每一组key:value的最后，以逗号,表示这一组的结束。

d = {
   'Alice': 45,
   'Bob': 60,
   'Candy': 75,
   'David': 86,
   'Ellena': 49
}

对于tuple中的组合数据类型，可变。

这里T有三个元素，第一个元素是数字类型，第二个元素是字符串类型，第三个元素是列表类型的，我们尝试修改第三个元素的数据。

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

创建单个元素的tuple

T = (1, )

义只有一个元素的tuple，需要在元素后面添加一个逗号,。

count()方法用来统计tuple中某个元素出现的次数。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
对于不存在的元素，count方法不会报错，而是返回0，这是合理的，因为元组里面有0个不存在的元素。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(10)) # ==> 0

index()方法返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。当指定的元素不存在时，使用index()方法Python会报错。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(1) # ==> 0 # 多次出现，返回第一次出现的位置

什么是tuple元组

元组(tuple)和list一样，也是一个有序容器，在元组中，同样可以包含0个或者多个元素，并且也支持索引访问、切片等操作。

tuple是固定不变的，一旦变成tuple，tuple中的每一个元素都不可被改变，同时也不能再往tuple中添加数据，而list是可以的。

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
L = list(T)#元组转换为列表
T = tuple(L)#列表转换为元组

Python二维list

alice_scores = [100, 89, 92]
bob_scores = [70, 65, 81]
candy_scores = [88, 72, 77]
all_scores = [alice_scores, bob_scores, candy_scores]
print(all_scores) # ==> [[100, 89, 92], [70, 65, 81], [88, 72, 77]]
score = all_scores[1][2] # ==> 81

有三个长方体，他们的长宽高分别是[1, 2, 3], [5, 3, 2], [7, 3, 2]，定义在数组L中，L = [[1, 2, 3], [5, 3, 2], [7, 3, 2]]，请分别求出三个长方体的表面积。

L = [[1,2,3], [5, 3, 2], [7,3,2]]
for cube in L:
    length = cube[0]
    width = cube[1]
    height = cube[2]
    result = length * width * 2 + width * height * 2 + length * height * 2
    print(result)

Python从list删除元素

pop()方法默认删除列表的最后一个元素，并返回。

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop()
print(name) # ==> Ellena
print(L) # ==> L = ['Alice', 'Bob', 'Candy', 'David']

pop()还可以接收一个参数，指定需要删除的元素的位置。

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop(2)
print(name) # ==> Candy
print(L) # ==> ['Alice', 'Bob', 'David', 'Ellena']

Python向list添加新的元素

用append()方法，把新同学追加到列表的末尾：

names = ['Alice', 'Bob', 'David', 'Ellena']
names.append('Candy')
print(names) # ==> ['Alice', 'Bob', 'David', 'Ellena', 'Candy']

insert()方法，插入当中。分别是需要插入的位置，以及需要插入的元素。

names = ['Alice', 'Bob', 'David', 'Ellena']
names.insert(2, 'Candy')
print(names) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']