1.容器型数据类型: 列表、元祖、字典、集合
1)列表:
[元素1, 元素2,...]
可变、有序
增删改查、+,*,>,<,>=,<=,==,!=,is、in,not in、len()、list()
多个数据的意义相同，并且需要支持增删改操作

2)元祖:
(元素1, 元素2,....)、 (元素1,)、 元素1, 元素2,....
不可变、有序
查、+,*,>,<,>=,<=,==,!=,is、in,not in、len()、tuple()
一般选择容器存储数据的时候不用元祖。 存储不可变数据的时候才用

3)字典
{键1:值1, 键2:值2,...} , 键 - 不可变的、唯一 值 - 任何类型的数据
可变、无序
增删改查、==,!=,is、in,not in、len()、dict()
保存的多个数据需要区分(意义/性质不同)

4)集合
{元素1, 元素2,...} 元素 - 不可变的、唯一
可变、无序
增删查、==,!=,is、in,not in、len()、set()、数学集合运算(|, &, -, ^, >=, <=)
注意: 集合遍历的效率高
做数学集合运算操作、去重、提高程序效率

2.函数

1. 声明
   def 函数名(参数列表):
   函数体

注意: 函数声明的时候不会执行函数体!

2. 调用
   函数(参数列表)

注意: 函数调用之前必须已经声明过
**调用过程:
回到函数声明的位置
传参(传参要保证每个参数都有值)
执行函数体
执行完函数体确定返回值
回到函数调用的位置(这个时候函数调用表达式的值就是返回值)

3. 参数
   位置参数、关键字参数 -- 保证位置参数在关键字参数的前面
   参数默认值
   类型说明
   不定长参数 -- args,*kwargs (面试题)

4. 返回值
   怎么确定返回值
   怎么获取返回值: 获取函数调用表达式的值

5. 其他
   lambda 参数列表: 返回值

变量的作用域:
全局变量: 声明在函数/类外部的变量是全局变量
局部变量: 声明在函数里面的变量就是局部变量

global: 在函数中声明全局变量
nonlocal: 想要在局部的局部中去修改局部变量的值

nums = [12, 3, 89, 90, 8]
nums.sort(reverse=True)
print(nums)

print('==================')
print(print('abc'))

func1 = lambda x: x*2
result = func1(10)
print(result)


list1 = [10, lambda x: x*x]
result = list1[1](10)
print(result)
# 1.编写函数，求1+2+3+…N的和
def yt_sum1(n):
    return sum(range(1, n+1))


print(yt_sum1(10))

2.编写一个函数，求多个数中的最大值

def yt_max(*nums):
    max1 = nums[0]
    for num in nums[1:]:
        if num > max1:
            max1 = num
    return max1


print(yt_max(19, 992, -93, 0))

4. 编写一个函数，交换指定字典的key和value

dict1 = {'a': 1, 'b': 2}    # {1: 'a', 2: 'b'}


def exchange_key_value(dictx: dict):

# 注意: 遍历删除和增加，遍历对象应该原来没有进行修改的原容器的值。

    for key in dictx.copy():
        value = dictx[key]
        print(key)
        dictx.pop(key)
        dictx[value] = key


exchange_key_value(dict1)
print(dict1)

9.写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束

例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True

字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False

def endswith(str1: str, str2: str):
    len2 = len(str2)
    end = str1[-len2:]
    return end == str2


if endswith('text.c', '.py'):
    print('是python源文件')
else:
    print('不是python源文件')

10.写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串

例如: '1234921' 结果: True

'23函数' 结果: False

'a2390' 结果: False

def isdigit(str1: str):
    for char in str1:
        if not '0' <= char <= '9':
            return False
    return True


print(isdigit('2a333'))

12.写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

例如: 原字符:'abc' 宽度: 7 字符:'^' 结果: '^^^^abc'

原字符:'你好吗' 宽度: 5 字符:'0' 结果: '00你好吗'

def rjust(str1: str, width: int, char: str):
    count = width - len(str1)
    return count*char+str1


print(rjust('abc', 7, '^'))
print(rjust('你好吗', 5, '0'))

13.写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1

例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0] 元素: 1 结果: 0,4,6

列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '赵云' 结果: 0,4

列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '关羽' 结果: -1

def index(list1: list, item):
    if item not in list1:
        return -1

    indexs = []
    for x in range(len(list1)):
        if list1[x] == item:
            indexs.append(x)
    return indexs


names = ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']
all_index = index(names, '赵云')
for x in all_index:
    names[x] = '子龙'

print(index(names, '关羽'))
print(names)

14.写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

例如: 序列:[-7, -12, -1, -9] 结果: -1

序列:'abcdpzasdz' 结果: 'z'

序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98} 结果: 98

print(max([23, 45, 34, 45]))
print(max({'name': '张三', 'zge': 16, 'gender': '女'}))


def yt_max(seq):
    if isinstance(seq, dict):
        values = list(seq.values())
    else:
        values = list(seq)
    max1 = values[0]
    for item in values[1:]:
        if item > max1:
            max1 = item

    return max1


print(yt_max([23, 45, 56, 56]))
print(yt_max({'a', 'nsh', 'bccc'}))
print(yt_max({'小明': 90, '张三': 76, '路飞

1.函数作为变量

python中声明函数其实就是声明一个类型是function的变量, 函数名就是变量名

所以普通变量能做的事情函数都可以做

def func1():
    print('这是一个函数')
    return 100

2. 一个变量可以给另外一个变量赋值

a = 10
b = a
print(b/2)
a = 'abc'
print(a)

c = func1     # 将函数名作为变量，给另一个变量赋值
print('=======')
print(c())
print('=======')
func1 = 12.5
print(func1)
# print(func1())    # TypeError: 'float' object is not callable

# 3. 一个变量可以作为容器的元素
print('===================================')
a = 10      # 声明一个变量，类型是整型
print(type(a))


# 声明一个变量，类型是function
def func2():
    print('这是函数2')
    return 100


print(type(func2))
list1 = [a, func2, func2()]
print(list1)
print('0:', list1[0] // 3)
print('1:', list1[1]())    # print('1:', func2())  -> print('1:', 100)

练习:

list2 = []
for i in range(5):
    def func(n):
        return i * 2
    list2.append(func)


list3 = []
for i in range(5):
    list3.append(lambda x: x*i)


print(list3[0](2), list3[1](2), list3[2](2))

list2 = []
i = 0 ~ 4
i = 0:  func, list2 = [func]
i = 1:  func, list2 = [func, func]
...
i = 4: list2 = [func,func,func,func,func]

list20, list21, list22

func, func, func

None, None, None

0, 2, 3

8, 8, 8

print(list2)
print(list2[0](3), list2[1](3), list2[2](3))

4. 变量可以作为函数的参数

函数作为函数的参数(实参高阶函数)

print('==============================')


def func1(fn, fn2):
    # fn = func11
    # fn2 = func12
    fn()   # func11(),  None
    print(fn2(3) / 4)  # print(9/4)


def func11():
    print('这是一个函数')


def func12(n):
    # n = 3
    return n**2


print(func1(func11, func12))   # print(None)


func1(func11, func12)

应用: sort函数

print('===============sort的高级使用===============')
nums = [1, 34, 45, 9, 20]
nums.sort()
print(nums)

all_students = [
    {'name': '小明', 'age': 19, 'score': 89},
    {'name': '熊大', 'age': 20, 'score': 90},
    {'name': '熊二', 'age': 17, 'score': 70},
    {'name': '光头强', 'age': 21, 'score': 40}
]

序列.sort函数中有个参数key，这个参数要求传一个函数，并且函数有一个参数和一个返回值

参数就是序列中的元素, 返回值就是排序比较的对象

def compare(item):

return item['age']

all_students.sort(key=compare)

all_students.sort(key=lambda item: item['age'])
print(all_students)

练习，将all_message中的元祖按照第二个元素从大到小排序。然后再按照学号的最后一位从小到大排序

all_message = [
('余婷', 'python1902004'),
('张三', 'python1902106'),
('小明', 'python1902027')
]

all_message.sort(key=lambda item: item[1], reverse=True)
print(all_message)

all_message.sort(key=lambda item: item[1][-1])
print(all_message)

def yt_sort(seq, key=None, reverse=False):
if key:
# 选择排序
length = len(seq)
for x in range(length - 1):
for y in range(x + 1, length):
if key(seq[y]) < key(seq[x]):
seq[x], seq[y] = seq[y], seq[x]
else:
# 选择排序
length = len(seq)
for x in range(length-1):
for y in range(x+1, length):
if seq[y] < seq[x]:
seq[x], seq[y] = seq[y], seq[x]

nums = [23, 45, 89, 9, 21]
yt_sort(nums)

nums.sort()

print(nums)

all_students = [
{'name': '小明', 'age': 19, 'score': 89},
{'name': '熊大', 'age': 20, 'score': 90},
{'name': '熊二', 'age': 17, 'score': 70},
{'name': '光头强', 'age': 21, 'score': 40}
]

all_students.sort(key=lambda x: x['age'])

yt_sort(all_students, key=lambda x: x['age'])
print(all_students)

all_students = [
{'name': '小明', 'age': 19, 'score': 89},
{'name': '熊大', 'age': 20, 'score': 90},
{'name': '熊二', 'age': 17, 'score': 70},
{'name': '光头强', 'age': 21, 'score': 40}
]
print(max(all_students, key=lambda x: x['score']))

5. 变量作为返回值

将一个函数作为函数的返回值(返回值高阶函数)

print('================返回值高阶函数==============')

def func1():
def temp(*nums):
return sum(nums)
return temp

print(func1()(1, 3, 5, 9)) # print(temp(1,3,5,9)) , print(18)

1.什么是迭代器(iter)

迭代器是容器型数据类型(可以同时存储多个数据), 但是想要获取/查看迭代器中元素的值，只能将元素取出来。

取出来的元素在迭代器中就不存在了，取的时候只能从前往后一个一个的取，不能跳着取。

2.迭代器中的元素

迭代器的元素只能通过类型转换，将其他容器转换成迭代器； 或者通过生成器去生成

1) 转换 - 所有序列都可以转换成迭代器。 迭代器中的元素可以是任何类型的数据

iter1 = iter([10, [1, 3]])
print(iter1)

3. 获取元素: 迭代器获取元素，不管以什么样的方式获取，获取后，这个元素在迭代器中就不存在了

1) next(迭代器) - 获取迭代器顶部数据(最上面的数据)

iter2 = iter('hello')
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))

print(next(iter2)) # StopIteration

2) 遍历获取每个元素

iter2 = iter('hello')
next(iter2)
next(iter2)
for x in iter2:
print('x:', x)

print(next(iter2)) # StopIteration

1.什么是生成器

生成器就是迭代器, 迭代器不一定是生成器

调用一个带有yield关键字的函数就能得到一个生成器。(yield只能出现在函数体中)

def func1():
print('=====')
return 100
yield

gen1 = func1()
gen2 = func1()
print(gen1, gen2)

2.生成器的元素

生成器获取元素的方式和迭代器一样： next()和循环遍历

1）生成器元素的个数: 看执行完生成器对应的函数会遇到几次yield

2) 元素的值: 看yield后表达式的值

def func2():
print('函数')
for x in range(10):
yield x

gen3 = func2()
print('next:', next(gen3))
print('next:', next(gen3))
print('next:', next(gen3))

print('next:', next(gen3))

for x in gen3:
print('x:', x)

3.生成器产生数据的原理

"""
当获取生成的元素的是，会执行生成器对应的函数，从开始执行到yield为止,将yield后面的数据作为元素返回并且记录结束位置；
下次获取元素的时候，从上次结束的位置接着往后执行，直到遇到yield, 将yield后面的数据作为元素返回并且记录结束位置；
以此类推
如果从开始执行到函数结束，没有遇到yield，那么就获取不到元素
"""
print('===============================')

def func3():
print('第一次')
yield 1
print('第二次')
yield 2
print('第三次')
yield 3

gen4 = func3()
print('next1:', next(gen4))

for x in range(100):
print('+++++++++++++')

print('next2:', next(gen4))
print('next3:', next(gen4))

nums = ['001', '002', '003', '004', '005', '006']

def func5():
for x in range(1, 6):
yield str(x).rjust(3, '0')
nums2 = func5()

print(next(nums2))
print(next(nums2))

能够产生无限数字的生成器

def func6():
num = 0
while True:
yield num
num += 1

gen5 = func6()