python 长结果

一、Python

1.1 注释

1.1 注释介绍

在我们工作编码的过程中，如果一段代码的逻辑比较复杂，不是特别容易理解，可以适当的添加注释，以辅助自己

或者其他编码人员解读代码。

没注释的代码

有注释的代码

注意：注释是给程序员看的，为了让程序员方便阅读代码，解释器会忽略注释。使用自己熟悉的语言，适当的对代
码进行注释说明是一种良好的编码习惯。

1.2 注释的分类

在Python中支持单行注释和多行注释。
单行注释
以#开头，#右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用。
快捷键 Ctil + /
或者 Shift + #

# #开头右边的都是注释，解析器会忽略注释
print('hello world') #我的作用是在控制台输出hello world

多行注释
以 ‘’’ 开始，并以 ‘’’ 结束，我们称之为多行注释。

'''
多行注释
'''
print('hello word')

2. 变量以及数据类型

2.1 变量的定义

对于重复使用，并且经常需要修改的数据，可以定义为变量，来提高编程效率。
定义变量的语法为: 变量名 = 变量值 。(这里的 = 作用是赋值。)
定义变量后可以使用变量名来访问变量值。

# 变量的意义: 重复的值书写修改起来很麻烦，
# 在不适用变量的情况下
print("今天天气很好")
print("今天天气很好")
print("今天天气很好")
print("今天天气很好")

# 在使用变量的情况下
# 变量的格式：变量的名称=变量的值
weather = "今天天气很好"
print(weather)
print(weather)
print(weather)

说明:

• 变量即是可以变化的量，可以随时进行修改。
• 程序就是用来处理数据的，而变量就是用来存储数据的。

2.2 变量的类型

程序中: 在 Python 里为了应对不同的业务需求，也把数据分为不同的类型。 如下图所示：

'''
Number (数字)
    int（有符号整形） 1 2 35 22
    lang（长整形也可以代表8进制和十六进制）
    float（浮点型） 1.2 1.23 44.212
    complex（复数）
布尔类型
    Tree 真
    False 假
String（字符串）
List （列表）
Tuple（元组）
Dictionary（字典）
'''

# 变量类型的基本使用
# Number 数量
# int
money = 5000
# float
money1 = 3.33

# boolean 布尔
# 流程控制语句
# 性别的变量
# 性别在世纪企业开发中使用的单词是sex gender
sex = True
gender = False

# String 字符串 （字符串使用的是单引号或者双引号）
s = '字符串'
s1 = "字符串2"

# 不允许一单一双
# s2 = 'sda“

# 单引号和双引号的嵌套
s3 = '"aaaasd"'
s4 = "'sadf2'"

# list 列表
# tuple 元组
# dict 字典
# 使用type() 可以查看变量存储的数据类型
# 列表
# 应用场景：当获取到了很多个数据的时候。那么我们可以将它们存储在列表中，然后直接使用列表访问
name_list = ['周杰伦','科比']
print(name_list)

# tuple 元组
age_tuple = (12,32,231)
print(age_tuple)

# dict 字典
# 应用场景：scrapy框架使用
person = {"name": "科比",
          "age": 12}
print(person)

print(type(person))

2.3 查看数据类型

• 在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的
  去说明它的类型，系统会自动辨别。也就是说在使用的时候 “变量没有类型，数据才有类型”。
• 比如下面的示例里，a 的类型可以根据数据来确认,但是我们没法预测变量 b 的类型。

# 使用type(变量名) 获取变量的数据类型

# int float boolean string list tuper dict
a = 1
print(type(a)) #<class 'int'>
b = True
print(type(b)) #<class 'bool'>

c = False
print(type(c))#<class 'bool'>

d = 3.3123
print(type(d))#<class 'float'>

e = 'sdfa'
print(type(e))#<class 'str'>

f = ["xxx","222"]
print(type(f))#<class 'list'>

g = ("111",222)
print(type(g))#<class 'tuple'>

h = {"111":222}
print(type(h))#<class 'dict'>

3. 标识符和关键字

计算机编程语言中，标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与
使用之间的关系。

• 标识符由字母、下划线和数字组成，且数字不能开头。
• 严格区分大小写。
• 不能使用关键字。

3.1 命名规范

• 标识符命名要做到顾名思义。

起一个有意义的名字，尽量做到看一眼就知道是什么意思(提高代码可 读性) 比如: 名字 就定义为 name , 定义学生 用 student

a = "zhangsan" # bad
name = "zhangsan" # good
b = 23 # bad
age = 23 # good

• 遵守一定的命名规范。
  驼峰命名法，又分为大驼峰命名法和小驼峰命名法。
  小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，
  例如：myName、aDog
  大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：
  FirstName、LastName.
• 还有一种命名法是用下划线“_”来连接所有的单词，比如send_buf. Python的命令规则遵循PEP8标准

3.2 关键字

• 关键字的概念 一些具有特殊功能的标识符，这就是所谓的关键字。
  关键字，已经被python官方使用了，所以不允许开发者自己定义和关键字相同名字的标识符。

False None True and as assert break class
continue def del elif else except finally for
from global if import in is lambda nonlocal
not or pass raise return try while with
yield

4.类型转换

• 转换成为整数

# 转换为整形
# str -> int
a = '123'
print(type(a)) #<class 'str'>
# 将字符串转换为整数
b = int(a)
print(type(b)) # <class 'int'>

# float -> int
c= 123.65656
print(type(c)) #<class 'float'>
# 将float转换为整数,南无会返回的是小数点前面的数据
d = int(c)
print(d) # 123
print(type(d)) # <class 'int'>

# boolean -> int
# Tree = 1 False =0
e= True
print(type(e)) #<class 'bool'>
# 将float转换为整数,南无会返回的是小数点前面的数据
f = int(e)
print(f) # 1
print(type(f)) # <class 'int'>

#  1231.231 和 123as 字符串都包含非法字符，不能被转换成为整数，会报错
# 字符串中包含非法字符不能转换为int 会报错
# g = "1231.231"
# print(int(g))
# h = "1231as"
# print(int(h))

• 转换成为浮点数

a = '123.232'
#  将字符串类型的数据转换为浮点数
b = float(a)
print(b)
print(type(b)) #<class 'float'>

# 将int 转换为浮点数
c = 123
d = float(c)
print(d) #123.0

• 转换成为字符串

# 整数转换为字符串
# a = 80
# print(type(a))
# # 强制类型转换为字符串的方法是str()
# b = str(a)
# print(type(b)) #<class 'str'>

# # 将小数转换为字符串
# a = 80.3234
# print(type(a))
# # 强制类型转换为字符串的方法是str()
# b = str(a)
# print(type(b)) #<class 'str'>

# 将bool转换为字符串
a = True
print(type(a))
# 强制类型转换为字符串的方法是str()
b = str(a)
print(b) #True

• 转换成为布尔值

# 注意：如果对非0的整数（包含整数，负数）转换为bool 结果都为Tree

# a=1
# print(type(a)) #<class 'int'>
# b = bool(a)
# print(b) #True
# print(type(b)) #<class 'bool'>

# a=2
# print(type(a)) #<class 'int'>
# b = bool(a)
# print(b) #True
# print(type(b)) #<class 'bool'>

# 在整数的范围内。0 强制类型转换为bool类型的结果是false
# a=0
# print(type(a)) #<class 'int'>
# b = bool(a)
# print(b) #False
# print(type(b)) #<class 'bool'>

# 浮点数
# 将浮点数转换为bool 类型的数据的时候。正负浮点数，结果都为True。0.0 结果为False
# a=0.2
# print(type(a)) #<class 'float'>
# b = bool(a)
# print(b) #True
# print(type(b)) #<class 'bool'>

# 字符串
# 只要字符串中有内容（包括空格），那么在强制类型转换为bool的时候，返回True
# a= "str"
# print(type(a)) #<class 'float'>
# b = bool(a)
# print(b) #True
# print(type(b)) #<class 'bool'>
# a= ""
# print(type(a)) #<class 'float'>
# b = bool(a)
# print(b) #False
# print(type(b)) #<class 'bool'>

# 列表
# 只要列表中有数据，那么强制类型转换bool时就返回True
# a= ["11","22"]
# print(type(a))
# b = bool(a)
# print(b) #True
# print(type(b)) #<class 'bool'>
# a= []
# print(type(a))
# b = bool(a)
# print(b) #False
# print(type(b)) #<class 'bool'>

# 元组
# 如果元组中没有数据的话就返回False ,有数据返回True
# a = ("11",22)
# print(type(a))
# b = bool(a)
# print(b) #True
# print(type(b)) #<class 'bool'>
# a= ()
# print(type(a))
# b = bool(a)
# print(b) #False
# print(type(b)) #<class 'bool'>

# 字典
# 如果字典中没有数据的话就返回False ,有数据返回True
a = {"name": "zhangs"}
print(type(a))
b = bool(a)
print(b) #True
print(type(b)) #<class 'bool'>
a= {}
print(type(a))
b = bool(a)
print(b) #False
print(type(b)) #<class 'bool'>

#什么情况下是False
print(bool(0))
print(bool(0.0))
print(bool(''))
print(bool(""))
print(bool([]))
print(bool({}))
print(bool(()))

5.运算符

5.1 算数运算符

下面以a=10 ,b=20为例进行计算

# a = 3
# b = 2
# print(a + b)
# print(a - b)
# print(a * b)
# print(a / b)
#
# # 取整
# print(a//b)
# # 取余
# print(a % b)
#
# # 指数 幂
# print(a ** b)
#
# # () 提高优先级
# print((2+3)*6)

# 扩展
# 字符串的加法 是进行拼接的
# a = '123'
# b = '456'
# print(a+b) # 123456

# 在python中两端都是字符串才可以进行加法运算
# a = "123"
# b = 234
# print(a + str(b)) #123234

# 字符串乘法: 将字符串重复多少次
a = "张三李四"
print(a * 3) #张三李四张三李四张三李四

注意：混合运算时，优先级顺序为： ** 高于 * / % // 高于 + - ，为了避免歧义，建议使用 () 来处理运算符优先级。 并且，不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

算数运算符在字符串里的使用

• 如果是两个字符串做加法运算，会直接把这两个字符串拼接成一个字符串。

5.2 赋值运算符

a = 10
print(a) #10

b = c = 20
print(b) #20
print(c) #20

d,e,f = 1,2,3
print(d) #1
print(e) #2
print(f) #3

5.3 复合赋值运算符

# += -+ *= /= //= %= **=

a = 1
# a = a+2
# print(a) # 3
a += 2 # a=a+2
print(a) # 3

b=2
# b乘3打印结果
# b = b*3
# print(b) #6
b*=3
print(b) #6

c = 4
# c=c-1
# print(c) # 3
c-=1
print(c) # 3

d = 6
# d = d/3
# print(d) #2.0
d/=3
print(d) # 2.0

e =6
e //= 3 # e = e // 3 (除整)
print(e)

f = 5
f %= 3 # f = f%3 (取余 取模 模余)
print(f)

# 求6的3次幂
g = 6
g **= 3 # g = g**3 （指数 幂）
print(g)

5.4 比较运算符

以下假设变量a为10，变量b为20：

# 比较运算符 == != > >= < <=

# 比较运算符返回的都是boolean 类型的数据
#  == 恒等 判断==两边的变量是否是一致的
a = 10
b = 20
print(a==b)
#  != 不等 判断!=两边的变量是否不一致
a = 10
b = 20
print(a!=b)
# 扩展 <> python2版本使用 python3遗弃

# > 大于
a = 10
b = 20
print(a>b)

# >=大于等于
a = 10
b = 20
print(a>=b)
# >=大于等于

# < 小于
a = 10
b = 20
print(a<b)

# <= 小于等于
a = 10
b = 20
print(a<=b)

5.5 逻辑运算符

# 逻辑运算符 and 与； or 或； not 非；

# and 与
# and 两边的数据必须都是true时，才返回true，只要有一端返回False，南无就返回false
# and 两端都是false的时候，返回false
print(10>20 and 10 >11) #false
print(10>5 and 10>11)#false
print(10>5 and 10>6)#true

# or 或者
# or的两端都是false 则返回false
print(10>20 or 10>21) #False
# or的两端有一端为true 则返回true
print(10>5 or 10 >20)
# or的两端两端为true 则返回true
print(10>5 or 10>6)

#  not 非 取反
print(not True) # false
print(not (19>20)) #True

性能提升

# and 的性能优化，当and前面的结果是true情况下，那么后面的代码就不在执行了
# a = 36
# a>10 and print("nihao")
# a<10 and print("nihao")

# or 的性能优化 当or的前面是true时,那么后面的代码就不执行了
a = 36
a>10 or print("nihao")
a<10 or print("nihao")

6. 输入输出

6.1 输出

# 普通输出
print("111")

# 格式化输出
# scrapy 框架的时候 Excel文件 mysql redis
# %s 代表的是字符串 %d代表的是数值
age = 15
name = "李四"
print("我的名字是%s，我的年龄是%d" %(name,age)) #我的名字是李四，我的年龄是15

6.2 输入

在Python中，获取键盘输入的数据的方法是采用 input 函数（至于什么是函数，咱们以后的章节中讲解），那么这
个 input 怎么用呢?
看如下示例:

name=input("请输入你的用户名")
print("我的名称是：%s" %{name})
password=input("请输入你的密码")
print("我的密码是：%s" %{password})

注意:

input()的小括号中放入的是提示信息，用来在获取数据之前给用户的一个简单提示
input()在从键盘获取了数据以后，会存放到等号右边的变量中 input()会把用户输入的任何值都作为字符串来对待

7. 流程控制语句

7.1 if判断语句

• if语句是用来进行判断的，其使用格式如下：

if 要判断的条件:
条件成立时，要做的事情

• demo1:

'''
if 关键字的语句结构
if 判断条件：
    代码（如果判断为true 的时候执行if下面的内容）
'''

age = 19
# 如果你的年龄大于18了，你就可以开车了
if int(age)> 18:
    print("你可以开车了")

# true 代表的是男。false代表是女
gender = True
if gender == True:
    print("你是男的")
else:
    print("你是女的")

• demo2:

# 在控制台输入一个字符串。如果你的年龄大于18岁，那么打印可以去网吧了
age = int(input("你今年多大了"))
if age > 18 :
    print("你可以去网吧了")

• 注意：代码的缩进为一个tab键，或者4个空格

7.2 if else

if-else的使用格式

if 条件:
满足条件时的操作
else:
不满足条件时的操作

demo1

'''
if else的语法
if 判断条件：
    判断条件为true的时候执行的代码
else：
    判断天剑为false的时候执行的代码
'''

age = 17
if age >= 18:
    print("你可以去网吧了")
else:
    print("回家写作业去吧")

demo2

# 在控制台上输入一个年龄，如果您的年龄大于18了，那么输出欢迎光临
# 红浪漫，男宾一位，否则输出回家洗洗睡吧
age = input("请输入您的年龄")
if int(age) >= 18:
    print("欢迎光临红浪漫，男宾一位")
else:
    print("回家洗洗睡吧")

7.3 elif

elif的功能
elif的使用格式如下:

if xxx1:
	事情1
elif xxx2:
	事情2
elif xxx3:
	事情3

说明:

当xxx1满足时，执行事情1，然后整个if结束
当xxx1不满足时，那么判断xxx2，如果xxx2满足，则执行事情2，然后整个if结束
当xxx1不满足时，xxx2也不满足，如果xxx3满足，则执行事情3，然后整个if结束

demo:

'''
在控制台上输入您的成绩分数
如果你考了90分以上。成绩为优秀
如果你考了80分以上，成绩为良好
如果你考了70分以上，成绩为中等
如果你考了60分以上，成绩为合格
否则，成绩不合格
'''

score = int(input("请输入您的分数"))

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
elif score >= 60:
    print("合格")
else:
    print("成绩不合格")

7.4 for

在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。
for循环的格式

for 临时变量 in 列表或者字符串等可迭代对象:
	循环满足条件时执行的代码

'''
循环字符串
range(5)
range(1,6)
range(1,10,3)
# 循环一个列表
'''

# 一个一个输出叫做遍也叫则循环

s='china'
print(s[0]) #c

# for
# 格式： for 变量 in 要遍历的数据：
#           方法体
#  i 是字符串中一个有一个字符的变量
# s是代表要遍历的数据
# for i in s:
#     print(i)

# range(5) 0-5 左闭右开区间（0,5）
# range 方法的结果一个可以遍历的对象
# for i in range(5):
#     print(i) # 0,1,2,3,4

# rang(1,6)
# rang(起始值，结束值)
# for i in range(1,6):
#     print(i) # 1,2,3,4,5

# range(1,10,3)
# range(起始值，结束值，步长)
# for i in range(1,10,3):
#     print(i) # 1,4,7

# 应用场景，会爬取一个列表返回给我们
# 循环一个列表
a_list = ["张三","王五","赵四"]
# 遍历列表中的元素
# for i in a_list:
#     print(i)

# 遍历列表中的下标
# print(len(a_list))
for i in range(len(a_list)):
    print(i)

8.数据类型高级

8.1 字符串高级

字符串的常见操作包括：

• 获取长度:len len函数可以获取字符串的长度。
• 查找内容:find 查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串中第一次出现的开始位置索引值，如果不存在，则返回-1.
• 判断:startswith,endswith 判断字符串是不是以谁谁谁开头/结尾 计算出现次数:count 返回 str在start和end之间 在 mystr里面出现的次数
• 替换内容:replace 替换字符串中指定的内容，如果指定次数count，则替换不会超过count次。
• 切割字符串:split 通过参数的内容切割字符串
• 修改大小写:upper,lower 将字符串中的大小写互换
• 空格处理:strip 去空格
• 字符串拼接:join 字符串拼接

'''
获取长度 len()
查找内容 find()
判断 startswith,endswith
计算出现次数 count
替换内容 replace
切割字符串 split
修改大小写 upper lower
空格处理 strip
字符串拼接 join
'''

# len length的缩写，长度
s = 'china'
print(len(s))

s1 = 'china'
print(s1.find('c')) # 返回在字符串中第一次出现的字符位置

s2 = 'china'
print(s2.startswith('c')) # 判断是否以某个字符开头
print(s2.endswith('c')) # 判断是否以某个字符结尾

s3 = "aaabbss"
print(s3.count('b')) # 统计字符串中符合条件的数量

s4 = 'cccdd'
print(s4.replace('c','d')) # 将字符串中符合条件的字符替换为另一个字符

s5 = "1,2,34,4"
print(s5.split(",")) # 将字符串以某个字符分割，返回一个列表

s6 = 'china'
print(s6.upper()) # 将字符串中所有小写转换为大写

s7 = 'CHINA'
print(s7.lower()) # 将字符串中所有大写转换为小写

s8 = '  s  '
print(s8.strip()) # 去掉字符串的首尾空格

s9 = 'a'
print(s9.join("hello")) # haealalao
#

8.2 列表高级

列表的增删改查
添加元素
添加元素有一下几个方法:

• append 在末尾添加元素
• insert 在指定位置插入元素
• extend 合并两个列表

# append 在列表的最后添加一个对象、数据
food_list = ['1','2']
food_list.append('3')
print(food_list)

# insert 插入
char_list = ['a','c','d']
#  index 的值就是你想插入数据的那个下标
char_list.insert(1,'b')
print(char_list)

# extend 合并两个集合
num_list = [1,2,3]
num1_list = [4,5,6]
num_list.extend(num1_list)
print(num_list)

修改元素
我们是通过指定下标来访问列表元素，因此修改元素的时候，为指定的列表下标赋值即可。

city_list = ['北京','上海','深圳','武汉','西安']
print(city_list)
# 列表的下标从0开始的
city_list[4] = '大连'
print(city_list)

查找元素
所谓的查找，就是看看指定的元素是否存在，主要包含一下几个方法：

• in 和 not in
  in, not in
  python中查找的常用方法为：
• in（存在）,如果存在那么结果为true，否则为false
• not in（不存在），如果不存在那么结果为true，否则false

food_list = ['鸡','鸭','鱼','肉']

# 判断一下在控制台输入的数据是否在列表中。
# food = input("请输入您想吃的食物")
# if food in food_list:
#     print("在")
# else:
#     print("不在")

# not in
ball_list = ["篮球","台球"]
ball = input("请输入你喜欢的球类")
if ball not in ball_list:
    print("不在")
else:
    print("在")

说明：

in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在

删除元素
类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删除掉；在开发中经常会用到删除
这种功能。
列表元素的常用删除方法有：

• del：根据下标进行删除
• pop：删除最后一个元素
• remove：根据元素的值进行删除

del

# a_list = [1,2,3,4,5]
#
# print(a_list)

# 根据下标来删除列表中的元素
# 爬取的数据中有个别的数据，是我们不想要的，那么我们就可以通过下标的方式来删除
# del a_list[2]
# print(a_list)

#  pop() 删除列表中最后一个元素
b_list = [1,2,3,4,5]
print(b_list)
b_list.pop()
print(b_list)

# remove() 根据元素值删除
c_list= [1,2,3,4,5]
print(c_list)
c_list.remove(3)
print(c_list)

8.3 元组高级

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

# 元组和列表的区别，元组的元素不能修改，元组使用小括号，列表使用方括号

a_tuple=(1,2,3,4)
print(a_tuple[0])

# 元组是不可以修改里面的内容的
# a_tuple[3] = 6

# 当 元组中只有一个元素的时候,那么他是整形数据
a_tuple = (5)
print(type(a_tuple))#<class 'int'>

# 定义只有一个元素的元组,需要在唯一元素后写一个逗号
a_tuple = (5,)
print(type(a_tuple))#<class 'tuple'>

8.4 切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]，也可以简化使用 [起始:结束]
注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

# 字符串/元组/列表都支持切片
s='hello word'
# 在切片中直接写一个下标
print(s[3]) # l

#  左闭右开区间,包含坐标的数据,不包含右边的数据
print(s[0:4]) #hell

# 从起始的值一直到结尾
print(s[1:]) #ello word

# 是从下标为0的索引的元素开始,一直到第二个参数为止,遵循左闭右开区间
print(s[:4]) #hell

# hello word
#  从下标为0的为止开始,到下标为6的为止结束,每次增长2个长度
print(s[0:6:2]) #hlo

8.5 字典高级

查看元素
除了使用key查找数据，还可以使用get来获取数据

# 定义一个字典

person = {'name': '吴老狗','age':28}

# 访问person的name
print(person['name'])
print(person['age'])

# 使用[]的方式.获取字典中不存在的key时会发生异常 keyerror
# print(person['sex'])
# python中不能使用.的方式获取对象值 如person.name

print(person.get('name'))

# 使用get的方式获取字典中不存在的key的时候会返回None 值,不会保错
print(person.get('sex')) #None

修改元素
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
demo:

person = {'name': '吴老狗','age':28}
#修改之前的字典
print(person)

# 修改name值为吴邪
person['name'] = '吴邪'
print(person)

添加元素
如果在使用 变量名['键'] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素
demo:添加新的元素

person = {'name': '吴老狗'}
# 给字典添加一个新的key value
# 如果使用变量名字['键'] = 数据时.这个键如果不存在那么就会编程新增元素,如果存在,就修改
person['age'] = 18
print(person)

删除元素
对字典进行删除操作，有一下几种：

• del
• clear()

demo:del删除指定的元素

# del
#  1. 删除字典中指定的某一个元素
person = {'name': '吴老狗','age':28}
print(person) #{'name': '吴老狗', 'age': 28}
del person['age']
print(person) #{'name': '吴老狗'}

#   2.删除整个字典
# del person
# print(person) # 他会将整个字典对象全部删除，
# clear

#  3.清空字典，但是保留字典对象
# 清空指的时将字典中所有的数据都删除掉，而保留字典的结构

# person.clear()
# print(person) ## {}

# 4. 重新赋值一个空对象
person = {}
print(person) ## {}

字典的遍历

# 遍历 --> 就是数据一个一个的输出
person = {'name': '吴老狗','age':28}

#1.遍历字典的key
# 字典.keys() 方法,获取的字典中所有的key值,key是一个变量的名字,我们可以随便起
for key in person.keys():
    print(key)

#2.遍历字典的value
# 字典.values() 方法,获取的字典中所有value值,value是一个变量的名字,我们可以随便起
for value in person.values():
    print(value)

#3.遍历字典的key和value
for key,value in person.items():
    print(key,value)

#5.遍历字典的项/元素
for item in person.items():
    print(item)```

 ### 9. 函数
思考：下列代码的问题

```py
print('欢迎马大哥光临红浪漫')
print('男宾2位')
print('欢迎马大哥光临红浪漫')
print('男宾2位')
print('欢迎马大哥光临红浪漫')
print('男宾2位')
print('欢迎马大哥光临红浪漫')
print('男宾2位')

9.1 定义函数

定义函数的格式如下：

def 函数名():
代码

示例：

# 很多重复的业务逻辑重复出现的时候,我们可以使用函数

# 定义函数
def f1():
    print("欢迎光临")

# 定义函数
f1()
f1()

9.2 调用函数

函数定义好以后，函数体里的代码并不会执行，如果想要执行函数体里的内容，需要手动的调用函数。
每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了。

9.3 函数参数

# 使用函数来计算1和2的和
def sum(a,b):
 print(a+b)

# 位置传参数,按照位置一一对应的关系来传递参数
sum(1,2)

# 关键字传参;不太常用
sum(b = 200,a = 400)

# 定义函数的时候.sum(a,b) 我们称a,b为形式参数 简称形参
# 调用函数的时候 sum(1,2) 我们称1和2为实际参数 简称实参

为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，就解决了这个问题，这就是 函数的参数
定义、调用带有参数的函数
定义一个add2num(a, b)函数，来计算任意两个数字之和:

def add2num(a, b):
	c = a+b
	print c
	add2num(11, 22) # 调用带有参数的函数时，需要在小括号中，传递数据

注意点：

在定义函数的时候，小括号里写等待赋值的变量名
在调用函数的时候，小括号里写真正要进行运算的数据

调用带有参数函数的运行过程：

调用函数时参数的顺序

>>> def test(a,b):
... print(a,b)
...
>>> test(1,2) # 位置参数
1 2
>>> test(b=1,a=2) # 关键字参数
2 1

• 定义时小括号中的参数，用来接收参数用的，称为 “形参”
• 调用时小括号中的参数，用来传递给函数用的，称为 “实参”

9.4 函数返回值

“返回值”介绍
现实生活中的场景:

我给女儿10块钱，让她给我买个冰淇淋。这个例子中，10块钱是我给女儿的，就相当于调用函数时传递到参
数，让女儿买冰淇淋这个事情最终的目标，我需要让她把冰淇淋带回来，此时冰淇淋就是返回值

综上所述：

• 所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果

带有返回值的函数

想要在函数中把结果返回给调用者，需要在函数中使用return
如下示例:

def add2num(a, b):
	c = a+b
	return c # return 后可以写变量名

或者

def add2num(a, b):
	return a+b # return 后可以写计算表达式

#  返回值关键字是return 存在函数中

def buyIceCream():
    return '冰淇淋'

#  使用一个遍历来接受函数的返回值
food = buyIceCream()
print(food)

# 案例练习
# 定义一个函数,然后让函数计算两个函数数值的和,并且返回这个计算之后的结果

def sum(a,b):
    return a+b

a = sum(111,3232)
print(a)

9.5 局部变量和全局变量

• 局部变量，就是在函数内部定义的变量
• 其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
  如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

# 局部遍历: 在函数的内部定义的变量,我们称为局部遍历
# 特点: 其作用域返回时函数内部，而函数的外部是不可以使用的
def f1():
    #  只能在函数内部使用
    a= 1
    print(a)
f1()
# print(a)

# 全部变量： 定义在函数外部的变量，我们称为全局变量
#  特点： 可以在函数外部使用，也可以在函数内部使用
b = 11
def f2():
    print(b)

f2()

# 在满足条件的清空，要使用作用域最小的那个变量范围

• 在函数外边定义的变量叫做 全局变量
• 全局变量能够在所有的函数中进行访问

10. 文件

10.1 文件的打开与关闭

打开文件/创建文件
在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
open(文件路径，访问模式)
示例如下：

f = open('test.txt', 'w')

说明:
文件路径

• 绝对路径：指的是绝对位置，完整地描述了目标的所在地，所有目录层级关系是一目了然的。 例如： E:\python
  ，
• 从电脑的盘符开始，表示的就是一个绝对路径。 相对路径：是从当前文件所在的文件夹开始的路径。 test.txt ，是在当前文件夹查找
  1. test.txt 文件,是在当前文件夹查找 test.txt 文件
  2. ./test.txt ，也是在当前文件夹里查找 test.txt 文件， ./ 表示的是当前文件夹。
  3. …/test.txt ，从当前文件夹的上一级文件夹里查找 test.txt 文件。 …/ 表示的是上一级文件夹
  4. demo/test.txt ，在当前文件夹里查找 demo 这个文件夹，并在这个文件夹里查找 test.txt 文件。

访问模式：

关闭文件
示例如下：

# 新建一个文件，文件名为:test.txt
f = open('test.txt', 'w')
# 关闭这个文件
f.close()

# open(文件路径，模式)
# 创建一个文件
# 模式： w 可写 r 可读

# 打开文件
f = open('text.txt', 'w')
# 写入文件
f.write("hello word")
f.close()

# 文件夹是不可以创建的，需要手动创建文件夹
fp = open("demo/text.txt",'w')
# 文件的关闭
fp.close()

10.2 文件的读写

写数据(write)
使用write()可以完成向文件写入数据
demo: 新建一个文件 file_write_test.py ,向其中写入如下代码:

# 写数据
# write方法
# fp = open("test.txt",'w')
# fp.write("helloword\n" * 5)
# fp.close()

# 如果文件存在会线清空原来的数据 然后再写
# 如果模式变成a，那么会执行追加的操作
# fp = open("test.txt",'a')
# fp.write("helloword\n" * 5)
# fp.close()

注意：

• 如果文件不存在，那么创建；如果存在那么就先清空，然后写入数据

读数据(read)
使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入
num，那么就表示读取文件中所有的数据
demo: 新建一个文件 file_read_test.py ，向其中写入如下代码:

# 读取数据
fp = open("test.txt",'r')
# 默认清空下，read 是一字节一字节的读，效率比较低
# content = fp.read()
# print(content)

# readline是一行一行的读取数据，但是只能读取一行
# content = fp.readline()
# print(content)

# readlines 可以按照行读取，但是会将所有数据都读取到，并且以一个列表的形式返回
# 而列表的元素是一行一行的数据
content = fp.readlines()
print(content)
fp.close()

注意：

• 如果用open打开文件时，如果使用的"r"，那么可以省略 open('test.txt')读数据（readline）
  readline只用来读取一行数据。

f = open('test.txt', 'r')
content = f.readline()
print("1:%s" % content)
content = f.readline()
print("2:%s" % content)
f.close()

读数据（readlines）
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行为列表的一个元素。

f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
for temp in content:
print(temp)
f.close()

10.3 序列化和反序列化

通过文件操作，我们可以将字符串写入到一个本地文件。但是，如果是一个对象(例如列表、字典、元组等)，就无
法直接写入到一个文件里，需要对这个对象进行序列化，然后才能写入到文件里。
设计一套协议，按照某种规则，把内存中的数据转换为字节序列，保存到文件，这就是序列化，反之，从文件的字
节序列恢复到内存中，就是反序列化。
对象—》字节序列 === 序列化
字节序列–》对象 ===反序列化
Python中提供了JSON这个模块用来实现数据的序列化和反序列化。

JSON模块
JSON(JavaScriptObjectNotation, JS对象简谱)是一种轻量级的数据交换标准。JSON的本质是字符串。
使用JSON实现序列化
JSON提供了dump和dumps方法，将一个对象进行序列化。
dumps方法的作用是把对象转换成为字符串，它本身不具备将数据写入到文件的功能。

import json
file = open('names.txt', 'w')
names = ['zhangsan', 'lisi', 'wangwu', 'jerry', 'henry', 'merry', 'chris']
# file.write(names) 出错，不能直接将列表写入到文件里
# 可以调用 json的dumps方法，传入一个对象参数
result = json.dumps(names)
# dumps 方法得到的结果是一个字符串
print(type(result)) # <class 'str'>
# 可以将字符串写入到文件里
file.write(result)
file.close()

dump方法可以在将对象转换成为字符串的同时，指定一个文件对象，把转换后的字符串写入到这个文件里。

import json
file = open('names.txt', 'w')
names = ['zhangsan', 'lisi', 'wangwu', 'jerry', 'henry', 'merry', 'chris']
# dump方法可以接收一个文件参数，在将对象转换成为字符串的同时写入到文件里
json.dump(names, file)
file.close()

使用JSON实现反序列化
使用loads和load方法，可以将一个JSON字符串反序列化成为一个Python对象。
loads方法需要一个字符串参数，用来将一个字符串加载成为Python对象。

import json
# 调用loads方法，传入一个字符串，可以将这个字符串加载成为Python对象
result = json.loads('["zhangsan", "lisi", "wangwu", "jerry", "henry", "merry", "chris"]')
print(type(result)) # <class 'list'>

load方法可以传入一个文件对象，用来将一个文件对象里的数据加载成为Python对象。

import json
# 以可读方式打开一个文件
file = open('names.txt', 'r')
# 调用load方法，将文件里的内容加载成为一个Python对象
result = json.load(file)
print(result)
file.close()

# fp = open('test.txt','w')
# # 默认情况我们只能将字符串写入到文件中
# fp.write("hello word")
# fp.close()

# fp = open('test.txt','w')
# # 默认情况下，对象是无法写入到文件中，如果想写入到文件，那么必须使用序列化的操作
# name_list = ['zhangsan',"lisi"]
# fp.write("hello word")
# fp.close()

# 序列化的2种方式
# dumps()
# 1.创建一个文件
# fp = open('test.txt','w')
# # 2.定义一个列表
# name_list = ['zhangsan',"lisi"]
#
# # 导入json模块到该文件中
# import json
# # 序列化
# # 我们在使用scrapy框架的时候，该框架会返回一个对象。我们要将对象写入到文件中，就要使用json.dumps()
# # 将python 对象变成一个json字符串
# names = json.dumps(name_list)
# print(type(names))
# # 将names 写入到文件中
# fp.write(names)
# fp.close()

# dump
# 在将对象转换为字符串的同时，指定一个文件的对象，然后吧转换后的字符串写入到这个文件里
# fp = open('test.txt','w')
# name_list = ['zhangsan',"lisi"]
# import json
# # 相当与names = json.dumps(name_list) 和  fp.write(names)
# names = json.dump(name_list,fp)
# fp.close()

#  反序列化
# 将json的字符串变成一个python对象
# fp = open('test.txt','r')
# content = fp.read()
# print(type(content)) #<class 'str'>
#
# # loads
# import json
# # 将json字符串转换为json对象
# result = json.loads(content)
# print(type(result)) #class 'list'>
# fp.close()


# loaddowload/template
fp = open('test_049.txt','r')
import json
result = json.load(fp)
print(result)
print(type(result))
fp.close()

11. 异常

程序在运行过程中，由于我们的编码不规范，或者其他原因一些客观原因，导致我们的程序无法继续运行，此时，
程序就会出现异常。如果我们不对异常进行处理，程序可能会由于异常直接中断掉。为了保证程序的健壮性，我们 在程序设计里提出了异常处理这个概念。

11.1 读取文件异常

在读取一个文件时，如果这个文件不存在，则会报出 FileNotFoundError 错误。

11.2 try…except语句

try…except语句可以对代码运行过程中可能出现的异常进行处理。 语法结构:

try:
	可能会出现异常的代码块
except 异常的类型:
	出现异常以后的处理语句

示例：

# 异常的格式
# try:
#     # 可能出现异常的代码
# except 异常的类型
#     友好的提示

try:
    fp = open("dowload/template/test01.txt",'r')
    fp.read()
    fp.close()
except FileNotFoundError:
    print("系统正在升级，请稍后再试")