以下为学python以来知识点及练习记录，用于个人知识点复习
DAY01-02 介绍、变量、格式化输出
1.python是编译型语言还是解释性语言，两种类型的语言的程序有什么不同？
答:解释型。
py文件”编译“完的结果是字节码，cpu还是执行不了，依然借助Python虚拟机解释执行。
但放宽了说，将高级语言转换为比它低级的语言再去解释执行（比如将源码翻译为字节码），也可以称之为编译过程的话，那么Python就不仅仅是解释型的语言
2.python相对与其他语言有什么优点和缺点？
优点：简单、易学、免费、开源、可移植性、解释性、面向对象、可拓展性、丰富的库、规范的代码
缺点：运行速度、国内市场小、中文资料匮乏、架构多
3.Python应用场景有哪些
web后端开发、网络爬虫与数据分析、人工智能等
4.注释：提高代码可读性
分为单行注释# 快捷键： ctr+/
多行注释""" """
5.变量：可用来存储数据，如字符串、数字等，可复用
每一个变量都存储这一种类型的数据，该数据的类型就是该变量的类型
6.标示符可以理解成是一套命名规则
常见的标示符的命名规则： 大驼峰命名法、小驼峰命名法，下划线连接命名法
7.格式化是指将数据按照预先定义好的格式处理数据的结构
格式化输出可以让开发者很方便的处理数据的，组装数据，然后将其输出
8.python交互模式：终端输入python
linux上通过vi、sublime、gedit等编辑器实现，文件后缀,py
9.注释单行#
多行
"""
注释内容
"""
10.变量的命名规则
1.只能由下划线、数字和字母组成
2.不能以数字开头
3.不能与关键字同名
4.应尽量避免与引用到的函数或库同名
注意，通过以下命令可以查看 Python 中的关键字
import keyword
print(keyword.kwlist)
# 判断是不是关键字
print(keyword.iskeyword('None'))
out(1)： True
11.python的数据类型：
数字型： 整型 (int)
浮点型（float）
布尔型（bool）
真 True 数学运算时表示 1
假 False 数学运算时表示 0
复数型 (complex)，基本不用
非数字型：
字符串
列表
元组
字典
12.进入python3交互模式，定义任意个变量，使用并查看其类型
>>> name="杜锦航"
>>> type(name)
<class 'str'>
>>>
13.大驼峰：
MyName="杜锦航"
小驼峰：
myName="杜锦航"
14.int(x) 将x转换为一个整数
long(x ) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
15. 取商：//
取余：%
16.>>> print(name)
杜锦航
>>> age=18
>>> height=173.00
>>> print("name is %s,age is %d,height is %.2f"%(name,age.height)
... )
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'height'
>>> print("name is %s,age is %d,height is %.02f"%(name,age.height)
... print("name is %s,age is %d,height is %.02f"%(name,age.height))
File "<stdin>", line 2
print("name is %s,age is %d,height is %.02f"%(name,age.height))
^
SyntaxError: invalid syntax
>>> print("name is %s,age is %d,height is %.02f"%(name,age.height))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'height'
>>> print(height)
173.0
>>> print("name is %s,age is %d,height is %2f"%(name,age.height))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'height'
>>> print("name is %s,age is %d,height is %f"%(name,age.height))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'height'
>>> print("name is %s,age is %d,height is %f"%(name,age,height))
name is 杜锦航,age is 18,height is 173.000000
>>>
打错符号，，，，，，，查了半天
17.
"""
编写一个cart.py(打印名片)程序
运行程序后，分别输入姓名、性别、年龄、单位、联系方式等数据，并用变量分别接收
输入完成后，最后打印出姓名、性别、年龄、单位、联系方式等信息，输出的格式自行设定，尽量美观
输出需使用上格式化输出
"""
name = input('请输入姓名')
company = input('请输入公司')
title = input('请输入职位')
phone = input('请输入电话')
email = input('请输入邮箱')
print(company)
print("*" * 30)
print("姓名：%s" % name)
print("职位:%s" % title)
print("联系电话：%s" % phone)
print("邮箱：%s" % email)
print("*" * 30)
结果：
F:\python\python.exe F:/pycharm/project/day01/cart.py
请输入姓名杜锦航
请输入公司宇通
请输入职位液压工程师
请输入电话15734039106
请输入邮箱15734039106@163.com
宇通
******************************
姓名：杜锦航
职位:液压工程师
联系电话：15734039106
邮箱：15734039106@163.com
******************************
DAY03 条件语句
1.# 练习: 定义一个整数变量 age，编写代码判断年龄是否正确,要求人的年龄在 0-120 之间
age = 19
if age >= 0 and age <= 120:
print("1")
else:
print("2")
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!注意符号和字母必须英文格式输入!!!!!!!!!!!!!!!!!!!!!!!!!
2.random()函数
import random
import string
# 随机整数：
print random.randint(1,50)
# 随机选取0到100间的偶数：
print random.randrange(0, 101, 2)
# 随机浮点数：
print random.random()
print random.uniform(1, 10)
# 随机字符：
print random.choice('abcdefghijklmnopqrstuvwxyz!@#$%^&*()')
# 多个字符中生成指定数量的随机字符：
print random.sample('zyxwvutsrqponmlkjihgfedcba',5)
# 从a-zA-Z0-9生成指定数量的随机字符：
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))
print ran_str
# 多个字符中选取指定数量的字符组成新字符串：
print ''.join(random.sample(['z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'], 5))
# 随机选取字符串：
print random.choice(['剪刀', '石头', '布'])
# 打乱排序
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print random.shuffle(items)
注意：输出需要print，试了好几次，忘了print，还纳闷怎么不出来随机数
DAY04 循环语句
1.
#!/usr/bin/python
# 定义一个行变量
row = 1
while row <= 5:
print("*"*row)
row += 1
2.在默认情况下，print 函数输出内容之后，会自动在内容末尾增加换行
如果不希望末尾增加换行，可以在 print 函数输出内容的后面增加 , end=""
其中 "" 中间可以指定 print 函数输出内容之后，继续希望显示的内容
语法格式如下：
# 向控制台输出内容结束之后，不会换行
print("*", end="")
# 单纯的换行
print("")
故，序号1也可：
#!/usr/bin/python
# 在控制台连续输出五行 *，每一行星号的数量依次递增
row = 1
while row <= 5:
rol = 1
while rol <= row:
print("*",end="")
rol += 1
print("")
row += 1
结果为：
F:\python\python.exe F:/pycharm/project/day01/XingXing.py
*
**
***
****
*****
3.九九乘法表
转义字符 描述
\ 反斜杠符号
\' 单引号
\" 双引号
\n 换行
\t 横向制表符
\r 回车
#!/usr/bin/python
# 在控制台连续输出五行 *，每一行星号的数量依次递增，把*换成行列相乘
row = 1
while row <= 9:
rol = 1
while rol <= row:
print(("%d*%d=%d")%(rol,row,row*rol),end="\t") #不换行 \t 对齐
print("") #手动换行
row += 1
结果：
F:\python\python.exe F:/pycharm/project/day01/XingXing.py
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
Process finished with exit code 0
4.运算符
运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c* a
/= 除法赋值运算符 c /= a 等效于 c = c / a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
%= 取 模 (余数)赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c** a
运算符优先级
运算符 描述
** 幂 (最高优先级)
* / % // 乘、除、取余数、取整除
+ - 加法、减法
<= < > >= 比较运算符
== != 等于运算符
= %= /= //= -= += = *= 赋值运算符
not or and 逻辑运算符
DAY05 列表、元祖
1.
列表用 [] 定义，数据 之间使用 , 分隔
例：a=[2,4,5]
b=['data','frog','python']
for 实现列表的遍历
例如：
for name in name_list:
循环内部针对列表元素进行操作
print(name)
2.
测量列表中元素的个数 len()
获取列表的某个元素
列表[索引] 向列表中添加元素 append() 、 extend() 、 insert()
如何删除列表中的某个元素？ del pop() remove()
如何修改列表中的某个元素？ 直接根据索引来修改 列表[要修改的元素的索引] = 值
如何去查找列表中某个元素所对应的下标？ 列表.index(元素)
升序排列：列表名.sort()
降序排列：列表名.sort(reverse=True)
3.
元组用 () 定义
例如：
a=(2,4,5)
b=('data','frog','python')
查询：
元组[索引] 根据索引取值，索引不存在会报错
元组.index(数据) 根据值查询索引，返回首次出现时的索引，没有查到会报错
元组.count(数据) 数据在元组中出现的次数
len(列表) 元组长度
if 数据 in 元组: 检查元组中是否包含某元素
4.
使用 list 函数可以把元组转换成列表 list(元组)
使用 tuple 函数可以把列表转换成元组 tuple(列表)
5.
# 编写代码设计简易计算器，可以进行基本的加减乘除运算。
num1 = int(input("请输入第一个数字:"))
symbol = input("请输入运算符")
num2 = int(input("请输入第二个数字:"))
if symbol == "+":
print("%d+%d=%d"%(num1,num2,num1*num2))
elif symbol == "-":
print("%d-%d=%d"%(num1,num2,num1-num2))
elif symbol == "*":
print("%d*%d=%d"%(num1,num2,num1*num2))
elif symbol == "/":
print("%d/%d=%d"%(num1,num2,num1/num2))
else:
print("请输入正确的运算符")
结果：
F:\python\python.exe F:/pycharm/project/day05/高级变量.py
请输入第一个数字:10
请输入运算符/
请输入第二个数字:5
10/5=2
Process finished with exit code 0
6.
# 使用while循环输出*
row = 1
while row <= 5:
print("*"*row)
row += 1
结果：
F:\python\python.exe F:/pycharm/project/day05/xingxing.py
*
**
***
****
*****
DAY06 字典
1.字典用 {key:value，...} 定义
例如：xiaoming = {"name": "小明",
"age": 18,
"gender": True,
"height": 1.75}
常用操作：
序号分类关键字 / 函数 / 方法说明
1增加字典[键] = 数据键不存在，会添加键值对；键存在，会修改键值对的值
2删除del 字典[键]删除指定的键值对
字典.pop(键)删除指定键值对,返回被删除的值
字典.clear清空字典
3修改字典[键] = 数据键不存在，会添加键值对；键存在，会修改键值对的值
字典.setdefault(键，数据)键值对不存在，添加键值对；存在则不做处理
字典.update(字典2)取出字典2的键值对，键值对不存在，添加键值对；存在则修改值
4查询字典[键]根据键取值，键值对不存在会报错
字典.get(键)根据键取值，键值对不存在不会报错
字典.keys()可进行遍历，获取所有键
字典.values()可进行遍历，获取所有值
字典.items()可进行遍历，获取所有(键，值)
2.字典应用场景
使用 多个键值对，存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息
将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理
字典的遍历：字典.keys()、字典.values()、字典.items()
3.字符串
注意：如果字符串内部需要使用 "，可以使用 ' 定义字符串
如果字符串内部需要使用 '，可以使用 " 定义字符串
可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
也可以使用 for 循环遍历 字符串中每一个字符
例：
string = "Hello Python"
for c in string:
print(c, end="")
结果：
Hello Python
常用操作;
判断
方法说明
string.isalpha()如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()如果 string 只包含数字则返回 True
string.islower()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
string.startswith(str)检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)检查字符串是否是以 str 结束，是则返回 True
查找和替换
方法说明
string.find(str, start=0, end=len(string))检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
string.rfind(str, start=0, end=len(string))类似于 find()，不过是从右边开始查找
string.index(str, start=0, end=len(string))跟 find() 方法类似，不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))类似于 index()，不过是从右边开始
string.replace(old_str, new_str, num=string.count(old))返回一个新字符串，把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次
拆分和连接
方法说明
string.partition(str)返回元组，把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)返回列表，以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格
string.splitlines()返回列表，按照行('\r', '\n', '\r\n')分隔
string1 + string2拼接两个字符串
string.join(seq)返回字符串，以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串
大小写转换
方法说明
string.lower()返回新字符串，转换 string 中所有大写字符为小写
string.upper()返回新字符串，转换 string 中的小写字母为大写
文本对齐
方法说明
string.ljust(width)返回新字符串，基于原字符串左对齐，并使用空格填充至长度 width
string.rjust(width)返回新字符串，基于原字符串右对齐，并使用空格填充至长度 width
string.center(width)返回新字符串，基于原字符串居中，并使用空格填充至长度 width
去除空白字符
方法说明
string.lstrip()返回新字符串，截掉 string 左边（开始）的空白字符
string.rstrip()返回新字符串，截掉 string 右边（末尾）的空白字符
string.strip()返回新字符串，截掉 string 左右两边的空白字符
4.切片
切片方法适用于字符串、列表、元组
字符串[开始索引:结束索引:步长]
注意：指定的区间属于左闭右开型 [开始索引, 结束索引) 对应
开始索引 <= 范围 < 结束索引
从头开始，开始索引 数字可以省略，冒号不能省略
到末尾结束，结束索引 数字和冒号都可以省略
步长默认为 1，如果元素连续，数字和冒号都可以省略
例如：
截取从 2 ~ 5 位置 的字符串
截取从 2 ~ 末尾 的字符串
截取从 开始 ~ 5 位置 的字符串
截取完整的字符串
从开始位置，每隔一个字符截取字符串
从索引 1 开始，每隔一个取一个
截取从 2 ~ 末尾 - 1 的字符串
截取字符串末尾两个字符
字符串的逆序（面试题）
答案：
num_str = "0123456789"
# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 从开始位置，每隔一个字符截取字符串
print(num_str[::2])
# 6. 从索引 1 开始，每隔一个取一个
print(num_str[1::2])
# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
# 9. 字符串的逆序（面试题）
print(num_str[::-1])
5.公用语法
内置函数
函数描述备注
len(item)计算容器中元素个数
del(item)删除变量del 有两种方式
max(item)返回容器中元素最大值如果是字典，只针对 key 比较
min(item)返回容器中元素最小值如果是字典，只针对 key 比较
注意：字符串 比较符合以下规则： "0" < "A" < "a"
切片
描述Python 表达式结果支持的数据类型
切片"0123456789"[::-2]"97531"字符串、列表、元组
运算符
运算符Python 表达式结果描述支持的数据类型
+[1, 2] + [3, 4][1, 2, 3, 4]合并字符串、列表、元组
*["Hi!"] * 4['Hi!', 'Hi!', 'Hi!', 'Hi!']重复字符串、列表、元组
in3 in (1, 2, 3)True元素是否存在字符串、列表、元组、字典
not in4 not in (1, 2, 3)True元素是否不存在字符串、列表、元组、字典
> >= == < <=(1, 2, 3) < (2, 2, 3)True元素比较字符串、列表、元组
注意：
in 在对 字典 操作时，判断的是 字典的键
in 和 not in 被称为 成员运算符
完整for循环语法
for 变量 in 集合:
循环体代码
else:
没有通过 break 退出循环，循环结束后，会执行的代码
例子：
students = [
{"name": "阿土",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 75.0},
{"name": "小美",
"age": 19,
"gender": False,
"height": 1.6,
"weight": 45.0},
]
find_name = "阿土"
for stu_dict in students:
print(stu_dict)
# 判断当前遍历的字典中姓名是否为find_name
if stu_dict["name"] == find_name:
print("找到了")
# 如果已经找到，直接退出循环，就不需要再对后续的数据进行比较
break
else:
print("没有找到")
print("循环结束")
结果：
{'name': '阿土', 'age': 20, 'gender': True, 'height': 1.7, 'weight': 75.0}
找到了
循环结束
6.登陆信息存入字典
"""
注册的校验程序:
A)实现循环从键盘输入用户名和密码
B)如果用户名或者密码任一一个输入的是“QUIT”直接退出程序。
C)判断用户名长度为6-20，用户名开头必须以字母开头。
D)密码长度至少6位，不能为纯数字，不能有空格。
E)如果不符合上述规则、打印出不符合的原因、提示重新输入。并跳转到用户名输入阶段。
F)将正确的用户名和密码存入字典里，并打印校验成功字样。
"""
user_info = {}
while True:
# 获取用户名和密码
username = input("input your username:")
password = input('input your password：')
# 如果用户名或密码任意一个是QUIT 直接退出
if username == 'QUIT' or password == 'quit':
break
# 判断用户名长度在6-20
elif len(username) < 6 or len(username) >20:
print('用户名长度不在6-20范围内')
break
# 用户名开头字母判断
elif not username[0].isalpha():
print('用户名必须以字母开头')
break
# 密码格式判断
elif len(password) < 6 or password.isdigit() or " " in password:
print("密码长度至少6位，不能为纯数字，不能有空格。")
break
else:
user_info[username] = password
print("校验成功")
print(user_info)
结果为：
input your username:dujinhang
input your password：djh123456
校验成功
{'dujinhang': 'djh123456'}
input your username:zhangsan
input your password：zs123456
校验成功
{'dujinhang': 'djh123456', 'zhangsan': 'zs123456'}
input your username:wangmazi
input your password：wmz123456
校验成功
{'dujinhang': 'djh123456', 'zhangsan': 'zs123456', 'wangmazi': 'wmz123456'}
input your username:wangmaz
input your password：123456
密码长度至少6位，不能为纯数字，不能有空格。
注意：更改break位置可以实现一直循环输入，删除后面3个break可以实现一直循环输入。删除后最后新增一个break可以在正确输入用户名和密码后结束
7.登陆
d = {'阿杜': 123456}
while True:
name = input('请输入您的用户名：')
if name in d:
break
else:
print('您输入的用户名不存在，请重新输入')
continue
count = 5
while count:
password = int(input('请输入您的密码：'))
if d[name] == password:
print('进入系统')
break
else:
count -= 1
print('您输入的密码不正确，还有{}次输入机会'.format(count))
continue
请输入您的用户名：阿杜
请输入您的密码：12345
您输入的密码不正确，还有4次输入机会
请输入您的密码：123456
进入系统
8.
# 从键盘获取5个学生的名字，然后随机抽出一名学生去打扫卫生
import random
name_list = []
i = 0
while i < 5:
name = input('输入学生姓名')
name_list.append(name)
i += 1
a = random.randint(0, 4)
print('打扫卫生的学生是%s' % name_list[a])
结果：
输入学生姓名张三
输入学生姓名里斯
输入学生姓名王麻子
输入学生姓名郭达
输入学生姓名杰森
打扫卫生的学生是杰森
注意：循环体要缩进，后续不循环的记得不要缩进！
DAY07 函数操作
1.定义函数的格式如下：
def 函数名(): 函数封装的代码
……
注释：
在开发中，如果希望给函数添加注释，应该在 定义函数的下方，使用 连续的三对引号，这种注释是给函数用的，方便给调用的人知道函数是怎么用的；
在连续的三对引号之间编写对函数的说明文字；
在函数调用位置，用使用鼠标点击函数名后，然后使用快捷键 CTRL + Q 可以查看函数的说明信息。
2.函数参数
形参：定义 函数时，小括号中的参数，是给真实数据占位用的，在函数内部 作为变量使用
实参：调用 函数时，小括号中的参数，是传递到 函数内部 的 真实数据
例子：
a = 5
def test1(a):
# 这里 a 是形参，是在函数内部定义的，作用域只在函数内部
a += 1
print("%d" % a)
test1(2)
# 这里因为形参的作用域不到这里，所以这个 a 是外面的 a
print("%d" % a)
结果：
3
5
注意，函数内部形参最好不要与外部变量同名
3.返回值
在程序开发中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
在函数中使用 return 关键字可以返回结果
调用函数一方，可以使用变量来接收函数的返回结果，也可以不接收只调用。注意没有返回值，也有返回值，是 None
注意：return 表示返回，后续的代码都不会被执行
例子：
def func_sum():
"""求和 1+2"""
sum_num = 1 + 2
print(sum_num)
return
# 这行代码不会执行了
print('不会执行这行代码')
res=func_sum()
print(res)
结果为;
3
None
例2：
# 计算1~num的累积和
def calculate_num(num):
result = 0
i = 1
while i <= num:
result = result + i
i += 1
return result
result = calculate_num(100)
print('1~100的累积和为:%d' % result)
4.函数的嵌套使用
定义一个函数能够打印 5 行 的分隔线，分隔线要求任意符号任意行数
def print_line(a, b):
print(a * b)
def print_lines(c, d):
row = 0
while row < 5:
print_line(c, d)
row += 1
print_lines("*", 30)
运行结果：
******************************
******************************
******************************
******************************
******************************
练习：
1.
# 设计一个程序，计算出 0-n 之间所有整数的和，并将计算的值返回。
def get_sum_num(n):
i = 0
sum_num = 0
while i <= n:
sum_num += i
i += 1
return sum_num
sum_num = get_sum_num(100)
print(sum_num)
注意：函数定义和循环体的冒号：
2.
"""
定义一个函数，要求输入大于0的数字n，判断传入数字的奇偶性，如果是奇数返回 "n是奇数"，否则返回 “n是偶数”，否则 返回“请输入大于0的整数”
"""
def jiou(n):
if n > 0:
if n/2 == 0:
return '%d是偶数' % n
else:
return '%d是奇数' % n
else:
return '请输入大于零的整数'
result = jiou(135)
print(result)
结果:
135是奇数
3.
"""
编写一个程序，通过键盘循环获取5个学生的信息，将学生信息组成字典保存到列表中，最终将学生信息列表打印出来。（学生信息包括 name 、age、id）
"""
stu_list = []
stu_dict={}
i = 0
while i < 5:
stu_dict = {}
name = input("请输入姓名:")
age = input("请输入年龄:")
id_stu = input("请输入学号:")
stu_dict["name"] = name
stu_dict["age"] = age
stu_dict["id"] = id_stu
stu_list.append(stu_dict)
i += 1
print(stu_list)
运行结果：
请输入姓名:张三
请输入年龄:12
请输入学号:123456
请输入姓名:李四
请输入年龄:23
请输入学号:234567
请输入姓名:王五
请输入年龄:34
请输入学号:456789
请输入姓名:周六
请输入年龄:45
请输入学号:567891
请输入姓名:刘七
请输入年龄:56
请输入学号:678912
[{'name': '张三', 'age': '12', 'id': '123456'}, {'name': '李四', 'age': '23', 'id': '234567'}, {'name': '王五', 'age': '34', 'id': '456789'}, {'name': '周六', 'age': '45', 'id': '567891'}, {'name': '刘七', 'age': '56', 'id': '678912'}]
DAY08 模块和匿名函数
1.模块
模块是 Python 程序架构的一个核心概念
模块就好比是 工具包，要想使用这个工具包中的工具，就需要导入 import 这个模块
每一个以扩展名 py 结尾的 Python 源代码文件都是一个模块
在模块中定义的 全局变量、函数都是模块能够提供给外界直接使用的工具
例子：
新建 info.py，代码如下
name = "datafrog"
def func():
print('info_func')
再新建 get_info.py 文件，并且编写以下代码：
import info
print(info.name)
info.func()
2.列表推导式：轻量级循环创建列表
例子：
a=[x for x in range(1,7) if x%2==0]
b=[x for x in range(1,7) if x%2!=0]
c=[x for x in range(1,7,2)]
print(a)
print(b)
print(c)
注意：第一个x可以是含x的参数
例2
d=[(x,y) for x in range(1,4) for y in range(3,5)]
输出结果：
[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]
3.匿名函数：用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤
例：
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print("Value of total : %s" % sum( 10, 20 ))
print("Value of total : %s" % sum( 20, 20 ))
以上实例输出结果：
Value of total : 30
Value of total : 40
例2：
下面的数据如何指定按age或name排序？
stus = [
{"name": "zhangsan", "age": 18},
{"name": "lisi", "age": 19},
{"name": "wangwu", "age": 17}
]
按name排序：
stus.sort(key = lambda x: x['name'])
print(stus)
输出结果：
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]
按age排序：
stus.sort(key = lambda x: x['age'])
print(stus)
输出结果：
[{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}
DAY09 函数高级
1.局部变量、全局变量
局部：函数内部定义
全局：函数外部定义
如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
例子：
a = 10
def test():
global a
a = 5 # 修改全局变量
print("函数内a：%d" %a)
test()
print("函数外a：%d" %a)
运行结果：
函数内a：5
函数外a：5
2.函数返回值
例子：
def func2():
return 1, 1.5
a = func2()
print(a)
a, b = func2()
print(a)
print(b)
a, b, c = 2, 2.5, "hello"
print(a)
print(b)
print(c)
结果 ：
(1, 1.5)
1
1.5
2
2.5
hello
3.函数参数
默认参数：调用函数时，如果没有传入默认参数对应的实参，则实参使用默认值。
关键字参数：调用函数时，实参可以指定对应的形参，称为关键字参数
例子：
def printinfo(name, age):
# 打印任何传入的字符串
print("Name: %s"% name)
print("Age: %s"% age)
printinfo(age=9,name="miki" )
结果：
Name: miki
Age: 9
可变参数
（1）、元祖：args
函数可以定义 可变参数，用于接收任意数量的参数
可变参数的前边需要添加*，用于提示python解释器该参数为可变参数
使用可变参数直接用args即可（不需要加*）
可变参数的本质是 将传递的参数包装成了元组
（2）、字典：kwargs
可变参数还有一种形式 可以接收不存在的关键字参数
定义参数时需要在变量名前添加两个*
这种可变参数会将 不存在的关键字参数包装成字典
例子：
def sum_num(a, b, *args, **kwargs):
print(a)
print(b)
print(args)
print(kwargs)
test(*args, **kwargs)
def test(*args, **kwargs):
print(args)
print(kwargs)
sum_num(1, 2, 3, mm=5, nn=6)
结果为：
1
2
(3,)
{'mm': 5, 'nn': 6}
(3,)
{'mm': 5, 'nn': 6}
例2：
#计算n到m的和，调用时可以不传，或传递1个或传递两个参数，默认计算1-100的和
def func3(n=1, m=100):
i = n
sum = 0
while i <= m:
sum += i
i += 1
return sum
print(func3(2, 5))
结果：
14
例3：#除法
def div(a, b, *args):
# 如果b=0，就让结果为a
if b == 0:
ret = a
else:
ret = a / b
if args:
for i in args:
if i == 0:
# 如果i=0，就跳过
continue
ret = ret / i
return ret
print(div(50, 2, 4))
例4：
# 使用不定长参数定义一个函数max_min，接受的参数类型是数值，最终返回这些数中的最大值和最小值
def max_min(*args):
if len(args) == 0:
return 0, 0
elif len(args) == 1:
return args(0), args(0)
else:
max = args[0]
min = args[0]
for i in args:
if max < i:
max = i
if min > i:
min = i
return max, min
print(max_min(1,2,5,6,8,5,25,))
例5：
# 定义一个函数，返回n的阶乘的最后结果，并打印出如5阶乘"5!=120"的效果
def num_factorial(a):
ret = 1
for i in range(a):
ret = ret * (i + 1)
print("%d!=%d" % (a, ret))
num_factorial(5)
例6
# 定义一个函数，返回由n(包含n)以内的奇数或者偶数组成的列表，默认返回全是奇数的列表
def jiou(n, type="jishu"):
res = []
if type == "jishu":
for i in range(1, n + 1):
if i % 2 != 0:
res.append(i)
if type == "oushu":
for i in range(i, n + 1):
if i % 2 == 0:
res.append(i)
return res
print(jiou(15))
运行结果
[1, 3, 5, 7, 9, 11, 13, 15]
例7：
"""
定义函数findall，实现对字符串find方法的进一步封装，要求返回符合要求的所有位置的起始下标，
如字符串"helloworldhellopythonhelloc++hellojava"，需要找出里面所有的"hello"的位置，
最后将返回一个元组(0,10,21,29)，即将h的下标全部返回出来，而find方法只能返回第一个
"""
def find_all(str1, date, start, end):
list1 = []
while start <= end:
i = str1.find(date, start, end)
if i == -1:
break
else:
start = i + 1
list1.append(i)
return tuple(list1) #元祖形式输出
str1 = "helloworldhellopythonhelloc++hellojava"
date = "hello"
end = len(str1)
print(find_all(str1, date, 0, end))
运行结果
(0, 10, 21, 29)
