文章目录
- Day3 数据类型
- Day4 string字符串截断、连接、复制
- Day5 list列表的索引、切片、连接、赋值
- Day6 tuple元祖的索引、切片、拆包
- Day7 dict字典的访问、修改、删除
- Day8 string和int类型互转
- Day9 string和dict类型转换，eval方法
- Day10 string和bytes类型转换，encode、decode方法
- Day11 dict和json格式互转，dumps、loads方法
- Day12 for循环和列表推导式创建列表
- Day13 生成器
- Day14 Random、String模块
- Day15 递归方法写阶乘函数
- Day16 map()函数
- Day17 filter()函数
- Day18 lambda函数
- Day19 位置参数、默认参数
- Day20 可变参数
- Day21 关键字参数
Day3 数据类型
Day3作业
建立几种常用的数据类型，包括int/float/string/list/tuple/dict等
int_a = 3
float_b = 8.8
string_c = "hello world"
list_d = ['abc', 2, 3.8, 'efg', 5]
tuple_e = ('abc', 2, 3.8, 4)
dict_f = {'name':'xiaoming', 'age':'18'}Day4 string字符串截断、连接、复制
Day4作业：
对于string数据，进行数据的截断/字符串的连接/复制当前的字符串
day_string = “21 day python”
1.截断：data_string[:]、data_string[1:9]、data_string[:-1]、data_string[0:]、data_string[::-1]
2.字符串的连接：data_string+“hello world”
3.复制当前的字符串：data_string*2
4.占位符:("%s"%data_string）
data_string = "21 day python"
print(data_string[:]) #21 day python
print(data_string[1:9]) #1 day py
print(data_string[:-1]) #21 day pytho
print(data_string[0:]) #21 day python
print(data_string[::-1]) #nohtyp yad 12
print(data_string+"hello world") #21 day pythonhello world
print(data_string*2) #21 day python21 day python
print("%s"%data_string) #21 day python总结：
1.切片操作基本表达式：object[start_index:end_index:step] step默认为1，可省略；为负值如-1时，是从右到左取值。
序列实现切片操作的语法格式如下：
sname[start : end : step]
其中，各个参数的含义分别是：
sname：表示序列的名称；
start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。
2.索引值以 0 为开始值，-1 为从末尾的开始位置
3.data_string[:] 表示取全部元素；data_string[:-1]表示取元素到-1，但不包括-1索引的元素；data_string[::-1]表示从右向左取元素；data_string[::-2]表示从右向左取元素，间隔1个取。
Day5 list列表的索引、切片、连接、赋值
Day5作业：
对于list类型数据,进行数据的索引/切片/列表的连接/对列表的赋值,列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(所谓嵌套)
data_list = [21, “day”, “python”]
1.索引: data_list[0] data_list[-1]
2.切片: data_list[:-1] data_list[::-1]
3.列表的连接: data_list.append(“helloworld”)
4.对列表的赋值:data_list*2 data_list[1:2] = “may” data_list[1:2]=[“may”]
分别写出data_list数据进行上述操作后的值分别为多少?
data_list = [21, "day", "python"]
print("data_list[0] ", data_list[0]) #21
print("data_list[-1] ", data_list[-1]) #python
print("data_list[:-1] ", data_list[:-1]) #[21, 'day']
print("data_list[::-1] ", data_list[::-1]) #['python', 'day', 21]
data_list.append("helloworld")
print("data_list.append('helloworld') ", data_list) #[21, 'day', 'python', 'helloworld']
print("data_list*2 ", data_list*2) #[21, 'day', 'python', 'helloworld', 21, 'day', 'python', 'helloworld']
data_list[1:2] = "may"
print(data_list) #[21, 'm', 'a', 'y', 'python', 'helloworld']
data_list[1:2] = ["may"]
print(data_list) #[21, 'may', 'a', 'y', 'python', 'helloworld']总结：
data_list[1:2] = “may”
print(data_list) #[21, ‘m’, ‘a’, ‘y’, ‘python’, ‘helloworld’]------这点没有理解。
Day6 tuple元祖的索引、切片、拆包
Day6作业
对于tuple类型数据，进行数据索引/切片/包含1个元素的元祖/元祖的拆包
data_tuple = (21, “day”, “python”)
1.索引：data_tuple[0]、data_tuple[-1]
2.切片：data_tuple[:-1]、data_tuple[::-1]
分别写出data_tuple数据进行上述操作后的值分别为多少？
3.写出包含1个元素的元祖？
4.拆包：data_1, data_2, data_3 = data_tuple, data_1，data_2，data_3分别返回什么值？
5.元祖和列表的区别？
元组是不可变的；列表是可变的。
data_tuple = (21, "day", "python")
print(data_tuple[0]) #21
print(data_tuple[-1]) #python
print(data_tuple[:-1]) #(21, 'day')
print(data_tuple[::-1]) #('python', 'day', 21)
data_tuple1 = ("21",)
print(data_tuple1) #('21',) 元组中只包含一个元素时，需要在元素后面添加逗号,
data_1, data_2, data_3 = data_tuple
print(data_1, data_2, data_3) #21 day pythonDay7 dict字典的访问、修改、删除
Day7作业
对于dict类型数据，进行访问字典内的值、修改字典、删除字典的元素
data_dict = {“location”:“shenzhen”,“province”:“guangzhou”,“age”:25}
1.访问字典内的值：data_dict[‘age’]
2.修改字典：data_dict[‘sex’] = 1
3.删除字典：del data_dict[‘sex’]
执行上述操作后，返回的值分别是多少？
data_dict = {"location": "shenzhen", "province": "guangzhou", "age": 25}
print(data_dict['age']) #25
data_dict['sex'] = 1
print(data_dict) #{'location': 'shenzhen', 'province': 'guangzhou', 'age': 25, 'sex': 1}
del data_dict['sex']
print(data_dict) #{'location': 'shenzhen', 'province': 'guangzhou', 'age': 25}Day8 string和int类型互转
Day8作业
string和int类型互转，分别写出下面几种场景下的代码？
1.string类型转int
a = “21”
1)10进制string转换成int
2)16进制string转换成int
2.int类型转string
a = 21
1)int转换成10进制string
2)int转换成16进制string
a = "21"
print(int(a)) #21
print(int(a, 16)) #33
a = 21
print(str(a)) #21
print(hex(a)) #0x15总结：
int(x [,base]) 将x转换为一个整数，base进制数，默认十进制
str(x) 将对象 x 转换为字符串
hex(x) 将一个整数转换为一个十六进制字符串
Day9 string和dict类型转换，eval方法
Day9作业
string和dict类型互转，分别写出下面几种场景下的代码？
1.string类型转dict,转完后检查数据类型是否修改
a = “{‘name’:‘idoxu’,‘sex’:‘name’,‘age’:30}”
2.dict类型转string,转完后检查数据类型是否修改
a = {‘name’:‘idoxu’,‘sex’:‘name’,‘age’:30}
a = "{'name':'idoxu','sex':'name','age':30}"
b = eval（a)
print("b:", b) #b: {'name': 'idoxu', 'sex': 'name', 'age': 30}
print(type(b)) #<class 'dict'>
a = {'name':'idoxu','sex':'name','age':30}
c = str(a)
print("c:", c) #c: {'name': 'idoxu', 'sex': 'name', 'age': 30}
print(type(c)) #<class 'str'>总结：
eval（str) 将字符串str当成有效的表达式来求值并返回计算结果.
eval（)将字符串转换成相应的对象（如list、tuple、dict和string之间的转换）
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
b = eval（a)
print(b) #[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
print(type(b)) #<class 'list'>Day10 string和bytes类型转换，encode、decode方法
Day10作业
string和bytes类型互转，分别写出下面几种场景下的代码？
1.string类型转bytes【“utf-8”格式】，转完后检查数据类型是否修改
a = “21 python”
2.bytes类型【“utf-8”格式】转string，转完后检查数据类型是否修改
a = b‘21python’
a = "21 python"
b = a.encode("utf-8")
print(b) #b'21 python'
print(type(b)) #<class 'bytes'>
a = b'21 python'
b = a.decode("utf-8")
print(b) #21 python
print(type(b)) #<class 'str'>总结：
encode() 方法为字符串类型（str）提供的方法，用于将 str 类型转换成 bytes 类型，这个过程也称为“编码”
decode() 方法用于将 bytes 类型的二进制数据转换为 str 类型，这个过程也称为“解码
encode() 方法的语法格式如下：
str.encode([encoding=“utf-8”][,errors=“strict”])
Day11 dict和json格式互转，dumps、loads方法
Day11作业
dict和json格式互转，分别写出下面几种场景下的代码？
1.dict类型转json，转完后检查数据类型是否修改
a = {‘name’:‘idoxu’,‘sex’:‘male’,‘age’:30}
2.json类型转dict，转完后检查数据类型是否修改
a = ‘{“name”:“idoxu”,“sex”:“male”,“age”:30}’
import json
a = {'name':'idoxu','sex':'male','age':30}
b = json.dumps(a)
print(b) #{"name": "idoxu", "sex": "male", "age": 30}
print(type(b)) #<class 'str'>
a ='{"name":"idoxu","sex":"male","age":30}'
b = json.loads(a)
print(b) #{'name': 'idoxu', 'sex': 'male', 'age': 30}
print(type(b)) #<class 'dict'>总结：
loads()：将json数据转化成dict数据
dumps()：将dict数据转化成json数据
load()：读取json文件数据，转成dict数据
dump()：将dict数据转化成json数据后写入json文件
Day12 for循环和列表推导式创建列表
Day12作业
分别使用for循环和列表推导式构建一个1-100的列表
list_a = []
for i in range(1, 101):
list_a.append(i)
print(list_a)
#列表推导式
list_b = [b for b in range(1, 101)]
print(list_b)总结：
列表推导式是Python构建列表（list）的一种快捷方式,可以使用简洁的代码就创建出一个列表。
列表推导式：list_b = [b for b in range(5)]
range()语法:range(start, stop[, step])
Day13 生成器
Day13作业
写出一个生成器表达式，检查所写的类型是否为生成器
generator_c = (c*2 for c in range(1, 5))
print(generator_c) #<generator object <genexpr> at 0x0000000002B94048>
print(next(generator_c)) #2
print(next(generator_c)) #4
for i in generator_c:
print("i:", i) #i:6 i:8总结：
1.在Python中，这种一边循环一边计算的机制，称为生成器：generator
2.创建一个generator，把一个列表生成式的[]中括号改为（）小括号，就创建一个generator
3.每次调用next(generaotr_c)就计算出他的下一个元素的值，直到计算出最后一个元素
4.generator也是可迭代对象，可以使用for循环
Day14 Random、String模块
Day14作业
1.写出6位的包含大小写在内的随机字符串
2.写出8位包含数字的随机数字
import random
import string
print(random.sample(string.ascii_letters, 6)) #['O', 'x', 'H', 'D', 'c', 'u'] 随机生成的字母
print("".join(random.sample(string.ascii_letters, 6))) #TlYZtA 随机生成的字母序列，用join方法连接成字符串
print(random.sample(string.digits, 8)) #['5', '9', '1', '2', '6', '4', '0', '7'] 随机生成的数字
print("".join(random.sample(string.digits, 8))) #48056123 随机生成的数字序列，用join方法连接成字符串总结：
1.random.sample(seq,n)从序列seq中选择n个随机且独立的元素
list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(random.sample(list, 3)) #[7, 3, 2] 随机打印列表中的3个元素2.string模块方法使用
print(string.ascii_letters) #abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.digits) #0123456789
print(string.ascii_lowercase) #abcdefghijklmnopqrstuvwxyz
print(string.ascii_uppercase) #ABCDEFGHIJKLMNOPQRSTUVWXYZ3.join()方法
join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
str.join(sequence)
print(" ".join(["hello", "world", "happy"]))
print("_".join(["hello", "world", "happy"]))
print("".join(["hello", "world", "happy"]))Day15 递归方法写阶乘函数
Day15作业
编写一个阶乘函数
def f(n):
if n < 2:
return 1
else:
return n * f(n-1)
print(f(3))
print(f(5))Day16 map()函数
Day16作业
map()会根据提供的函数对指定的序列做映射，即将函数依次作用在列表中的每一个元素上，形成一个新的列表。
将列表[1,2,3,4,5]中的每个元素都平方
def square(x):
return x ** 2
print(map(square, [1, 2, 3, 4, 5])) #<map object at 0x0000000000774648>
print(list(map(square, [1, 2, 3, 4, 5]))) #[1, 4, 9, 16, 25]总结：
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每一个元素，并把结果作为新的Iterable返回。其语法格式为：
map(function，iterable…)
function—函数名
iterable—一个或多个序列
Python 3.x map()返回的是一个map对象，要得到结果，必须用list作用于这个map对象。
def f(a, b):
return a + b
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 9]
print(list(map(f, list1, list2))) #[7, 9, 11, 13, 14]Day17 filter()函数
Day17作业
filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新的列表。
找出列表[1,2,3,4,5,6,7,8,9,10]中的奇数。
def is_odd(n):
return n % 2 == 1
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(filter(is_odd, list1)) #<filter object at 0x0000000002B66BC8>
print(list(filter(is_odd, list1))) #[1, 3, 5, 7, 9]总结：
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
filter(function, iterable)
function – 判断函数。
iterable – 可迭代对象。
Day18 lambda函数
Day18作业
使用lambda函数将列表[1,2,3,4,5]中的每个元素都平方
print(list(map(lambda x: x*x, [1, 2, 3, 4, 5]))) #[1, 4, 9, 16, 25]
print(list(map(lambda x: x*x, range(1,6)))) #[1, 4, 9, 16, 25]总结：
Python使用lambda关键字创造匿名函数
lambda [arg1[, arg2, … argN]]: expression
其中，参数是可选的，如果使用参数的话，参数通常也会在表达式之中出现。
add = lambda x, y: x + y
print(add(3, 4)) #7Day19 位置参数、默认参数
Day19作业
1.位置传参是最简单的传入参数的方式
def func(a, b):
print(a+b)
func(1, 2)
2.默认参数表示在调用函数的时候使用一些包含默认值的参数，默认值的参数也可覆盖
def func(a, b=2):
print(a+b)
func(1)
func(1,4)
分别写出函数的值是多少？
def func1(a, b):
print(a + b)
# func1(1) #报错
func1(1, 4) #5
def func2(a, b = 2):
print(a + b)
func2(1) #3
func2(1, 4) #5Day20 可变参数
Day20作业
可变参数允许在调用参数的时候传入多个（>=0个）参数（类似于列表、字典）
def func(args):
print(args)
print(args[0])
func(‘P’,‘y’,‘t’,‘h’,‘o’,‘n’)
func(‘Python’,123,‘爬虫’)
func((1,2,3))
分别写出函数的值是多少？
def func3(*args):
print(args)
print(args[0])
func3('P', 'y', 't', 'h', 'o', 'n') #('P', 'y', 't', 'h', 'o', 'n') P
func3('Python', 123, '爬虫') #('Python', 123, '爬虫') Python
func3((1,2,3)) #((1, 2, 3),) (1, 2, 3)Day21 关键字参数
Day21作业
关键字函数允许在调用时以字典形式传入0个或多个参数
def func(x, **kwargs):
print(x)
print(kwargs)
print(‘总共有%d个参数’ %len(kwargs))
print(‘这些参数分别为：’,kwargs)
func(20,name=“rose”,age=18)
分别写出函数的值是多少？
def func4(x, **kwargs):
print(x)
print(kwargs)
print('总共有%d个参数' % len(kwargs))
print('这些参数分别为：', kwargs)
func4(20, name = "rose", age = 18)
# 20
# {'name': 'rose', 'age': 18}
# 总共有2个参数
# 这些参数分别为： {'name': 'rose', 'age': 18}
