注释
  单行注释

单行注释

  多行注释
'''
多行注释，可以写多行功能说明
或
"""
多行注释，可以写多行功能说明
变量的定义和输出
变量的定义
   所谓变量可以理解为一个容器，它是用于存储数据的，方便后续再次使用存储的这个数据。
语法格式:
   变量名 = 数据

定义一个num1变量，存储数据2

num1 = 2

定义一个num2变量，存储数据3

num2 = 3

定义一个result变量，存储数据为 num1 + num2 的结果

result = num1 + num2

给多个变量赋值

a = b = c = 8
name, age, sex = "吕布", 30, "男"
输出
   把数据输出到控制台。输出使用的函数为：print，代码如下:

直接把数据5输出控制台

print(5)

输出result这个变量保存的数据

print(result)

输出多个变量

print(name, age, sex)
数据类型
常用的数据类型：
   int（整型），也就是整数，比如：100，30，5
   float（浮点型），也就是小数， 比如：3.14，5.9
   bool（布尔类型）
    True：真
    False：假
   str（字符串），比如："hello"
   list（列表），比如：[1, 3]
   tuple（元组），比如：(5, 6)
   dict（字典），比如：{"name": "李四"}
示例代码:
num1 = 1
num2 = 3.14
result = True
name = '李四'
print(num1, num2, result, name)
查看数据类型
   使用 type(数据/变量) 函数

查看变量保存数据的类型

print(num1, type(num1))
print(num2, type(num2))
print(result, type(result))
print(name, type(name))
运算符
   算术运算符
   比较（关系）运算符
   赋值运算符
   逻辑运算符
   位运算符
   成员运算符
   身份运算符
   运算符优先级
算术运算符
  以下假设变量： a=2，b=3：
运算符 描述 实例

• 加 - 两个对象相加 a + b 输出结果 5

• 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -1

• 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a b 输出结果 6
  / 除 - x除以y b / a 输出结果 1
  // 取整除 - 返回商的整数部分（向下取整） 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
  % 取模 - 返回除法的余数 b % a 输出结果 1
  幂 - 返回x的y次幂 ab 为2的3次方， 输出结果 8
  赋值运算符
  = 赋值运算符 把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 3，结果num的值为7
  复合赋值运算符
  += 加法赋值运算符 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
  比较运算符
  运算符 描述 示例
  == 比较两个操作数的值相等，如果是则条件变为真。 如a=3,b=3，则（a == b) 为 True
  != 比较两个操作数的值不相等，如果值不相等，则条件变为真。 如a=1,b=3，则(a != b) 为 True

  比较左操作数的值大于右操作数的值，如果是，则条件成立。 如a=7,b=3，则(a > b) 为 True
  < 比较左操作数的值小于右操作数的值，如果是，则条件成立。 如a=7,b=3，则(a < b) 为 False
  = 比较左操作数的值大于或等于右操作数的值，如果是，则条件成立。 如a=3,b=3，则(a >= b) 为 True
  <= 比较左操作数的值小于或等于右操作数的值，如果是，则条件成立。 如a=3,b=3，则(a <= b) 为 True
  <> 不等于 - 比较两个对象是否不相等。python3 已废弃。 (a <> b) 返回 true。这个运算符类似 != 。
  age = int(input("请输入您的年龄:"))
  print(age, type(age))
  print("if语句要开始判断啦。。。")
  if age == 18:

  只有if语句条件成立，则if语句里面的这个代码才会执行

  print("哈哈，幸福的十八岁")
  print("if语句判断结束啦。。。")
  逻辑运算符
     假如想要判断多个条件，而且多个条件之间还有一定的逻辑关系，此时需要使用逻辑运算符
  运算符 逻辑表达式 描述 实例
  and x and y 表示并且的关系，左右两边两个条件都要成立 True and False， 返回 False。
  or x or y 表示或者的关系，左右两边两个条件有其中一个成立即可 False or True， 返回 True。
  not not x 表示取反的关系 not True 返回 False
  user_name = input("请输入您的用户名:")
  user_pwd = input("请输入您的密码:")

  and 用法

  if user_name == "admin" and user_pwd == "123456":
  print("登录成功")

  or 用法

  height = float(input("请输入你的身高(m):"))
  weight = float(input("请输入您的体重(kg):"))

  or: 表示或者的关系，左右两边有其中的一个条件满足就可以执行if语句

  if height == 1.75 or weight > 75:
  print("成功找到了你们!")

  not 用法

  sex = input("请输入您的性别")
  if not sex == "男":
  print("你是女生")
  其他运算符详见：https://www.runoob.com/python/python-operators.html#ysf2
  输入
  input函数的使用
     需求: 获取用户在键盘上输入的密码，然后在控制台输出

  input函数的用法: input("输入提示的信息")

  username = input("请输入用户名:")
  password = input("请输入密码:")
  print("用户名为:", username, "，密码为:", password)
  数据类型转换
     因为输入的数据都按str（字符串）进行输出，需要对数据类型进行转换。
  常用的数据类型转换
  类型转换操作 说明
  int(x) 将x转换为一个整数
  float(x) 将x转换为一个浮点数
  str(x) 将 x 转换为字符串
  eval(str) 将字符串转成原始数据类型，也就是获取字符串中包裹的数据
  num_str = '365'
  print("num_str:", num_str, "数据类型为:", type(num_str))

  把字符串转成int类型

  num = int(num_str)
  print("num:", num_str, "数据类型为:", type(num))
  decimal = 3.14

  把float类型转成int

  integer = int(decimal)
  print("integer:", integer, "数据类型为:", type(integer))
  pi_str = "3.14"

  把字符串转成float类型

  float_value = float(pi_str)
  print("float_value:", float_value, "数据类型为:", type(float_value))
  int_value = 5

  把int类型转成float类型

  result = float(int_value)
  print("result:", result, "数据类型为:", type(result))

  把数字类型转成字符串

  str1 = str(10)
  str2 = str(5.5)
  print("str1:", str1, "数据类型为:", type(str1))
  print("str2:", str2, "数据类型为:", type(str2))
  num = 66

  把字符串转成原始数据类型

  eval_num = eval(num)
  print("eval_num:", eval_num, "数据类型为:", type(eval_num))
  字符串格式化
     当字符串中有动态数据时则可以使用字符串格式化。
  字符串格式化的方式
  格式化占位符
  f 字符串
  format 字符串
  格式符号 转换
  %s 格式化一个字符串
  %d 格式化一个整数
  %f 格式化一个浮点数
  name = "王大锤"
  age = 38
  salary = 14380.56

  %f默认保留6位小数

  print("姓名: %s 年龄: %d 薪资: %f" % (name, age, salary))

  %.2f：保留两位小数

  print("姓名: %s 年龄: %d 薪资: %.2f" % (name, age, salary))
  输出结果:
  姓名: 王大锤 年龄: 38 薪资: 14380.560000
  姓名: 王大锤 年龄: 38 薪资: 14380.56
  f字符串
     f字符串是python3.6中新增的格式化方式
     引用是前面必须加f（不区分大小写），调用时需使用{}进行调用

  f字符串的用法

  print(f"姓名: {name} 年龄: {age} 薪资: {salary}")

  f字符串的用法，.1f：保留1位小数

  print(f"姓名: {name} 年龄: {age} 薪资: {salary:.1f}")
  姓名: 王大锤 年龄: 38 薪资: 14380.6
  format字符串
     format字符串是字符串提供的一个方法，可以对字符串中的动态内容进行格式化
  result = "姓名: {} 年龄: {} 薪资: {}".format(name, age, salary)

  format方法 浮点数保留一位小数的写法

  result = "姓名: {} 年龄: {} 薪资: {:.1f}".format(name, age, salary)
  条件语句
  if 条件语句的分类
  if 条件语句
  if - else 条件语句
  if - elif -else 条件语句
  语法:
  if 要判断的条件:
  当条件满足，才会执行if语句里面的代码，否则if语句里面的代码不会执行
  print("if语句要开始判断啦。。。。。")
  if age >= 18:
  print("哥已成年，可以进入网吧肆无忌惮的玩耍!")
  print("if语句判断结束啦")
     当条件满足时执行A操作，否则不满足执行B操作，则可以使用if - else 条件语句
  条件满足执行if语句
  else:
  条件不满足执行else语句
  代码:

  判断年龄是否成年

  条件满足执行if语句

  print("哥成年了，可以进入网吧啦!")

  不满足条件执行else语句

  print("对不起，再忍几年!")
     当需要从上往下依次判断多个条件时，则可以使用if - elif -else 条件语句
  当条件成立执行相关的代码，后面的条件则不会再进行判断了，该语句执行结束
  elif 要判断的条件:
  以上列举的条件都不满足是，则会执行else语句
  注意点:
     1、当满足其中的某个条件时，则后面的条件不再进行判断，该语句执行结束
     2、当列举的所有条件都不满足时，则会执行else语句
  需求: 根据用户输入的分数进行评级

  1. 接收用户输入分数

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

  2. 依次判断该分数是否属于某个范围

  if score >= 90 and score <= 100:
  print("优秀")
  elif score >= 80 and score < 90:
  print("良好")
  elif score >= 70 and score < 80:
  print("一般般")
  elif score >= 60 and score < 70:
  print("刚刚及格")
  elif score >= 0 and score < 60:
  print("不及格")
  print("请输入合法分数，分数的范围：0-100.")
  当判断一个连续范围的时候，可以支持连续比较
  上面代码的简写方式：

  提示：

  if 90 <= score <= 100:
  elif 80 <= score < 90:
  elif 70 <= score < 80:
  elif 60 <= score < 70:
  elif 0 <= score < 60:
  if 嵌套语句
     在一个if语句里面再次使用一个if语句该格式称为if语句的嵌套
  执行相关的代码
  if 要判断的条件:
  执行相关的代码
  需求：男生找女朋友，先判断性别，性别没有问题 再判断年龄。

  1. 接收用户输入的性别

  sex = input("请输入您的性别:")

  2. 判断用输入的性别，当性别没有问题，在判断用户输入的年龄。

  if sex == "女":
  print("性别没有问题")
  age = int(input("请输入您年龄:"))

  判断年龄

  if 20 <= age <= 27:
  print("找到心中女神, 嘻嘻~")
  else:
  print("对不起，我们不太合适!")
  print("对不起，我们只要女生!")
  循环语句
  循环语句的分类
  while循环
  for循环
  while 要判断的条件:
  条件满足会执行while循环语句里面的代码
  实例：

  循环打印5次"人生苦短，我用python"

  记录当前循环的次数

  count = 1
  while count <= 5:
  print("人生苦短，我用python")
  count += 1
  死循环
  while True:
  重复执行相关的代码
  while循环的特点：
     1、会重复的判断条件是否成立，只要条件成立则就会执行循环语句里面的代码
     2、当条件不成立时，则while循环语句执行结束。
  while循环嵌套
     在一个while循环语句里面再次使用while循环语句该格式称为while循环嵌套
  条件满足，执行循环语句里面的代码
  while 要判断的条件:
  条件满足，执行循环语句里面的代码
  while count <= 3:
  print("当前循环的是第%d次!" % count)
  num = 1
  while num <= 3:
  print("天天向上！")
  num += 1
     可以直接对容器类型中的数据进行遍历。
     提示：for循环遍历的数据不使用，则可以使用 _ 替换。
  for 临时变量 in 要遍历的数据(字符串，列表，元组，字典，集合，range等):
  print(临时变量)
  需求:
    定义一个变量 message = "Hello Python"，使用for循环遍历获取每一个数据并输出到控制台
  message = "Hello Python"

  for遍历字符串

  for data in message:
  print(data)
  for循环结合range使用
     range表示数据范围，属于容器类型，这个范围里面可能有多个数字
  range的语法:
  range(开始数据, 结束数据, 步长)
  提示:
  开始数据不指定默认从0开始
  结束数据不包含
  步长不指定默认是1
  需求1：
    利用range，生成1到3的数据
  for value in range(1, 4):
  print(value, end = "\t")
  需求2：
    利用range，生成3到1的数据
  for num in range(3, 0, -1):
  print(num)
  需求3:
    利用range，循环打印3次 “天天向上!”

  for循环遍历的数据不使用，则可以使用_替换。

  for in range(3):
  print("天天向上!")
  for循环嵌套
     在一个for循环语句里面再次使用for循环语句该格式称为for循环嵌套
  for 临时变量 in 要遍历的数据(字符串，列表，元组，字典，集合，range等):
  print(临时变量)
     循环3次，输出“当前是第n次循环”，每循环一次，输出3次“天天向上！”
  for count in range(1, 4):
  print("当前是第%d次循环" % count)
  for in range(3):
  print("走上人生巅峰")
  循环语句结合else语句使用
  特点:
     当循环语句里面没有执行break操作，则else语句会执行
     当循环语句里面执行break操作，则else语句不会执行
  for value in range(1, 6):
  if value == 3:

  循环语句里面执行了break表示循环语句非正常结束，则else语句不执行。

  break

  执行了continue语句也会执行else语句。

  提示：for循环结合continue使用，会自动取下一个值。

  continue
  print(value)

  只有循环语句里面执行了break，则else语句不执行。

  print("循环语句里面没有执行break，表示循环正常结束，可以执行else语句"
  break和continue
     break作用：终止所在循环，该循环执行结束
     continue作用：结束本次循环，然后可以继续执行下次循环
     提示：break 和 continue只能在循环语句（while，for）里面使用，不能单独使用。
  break的使用
  num = 1
  while num <= 6:
  if num == 3:

  终止所在循环，该循环执行结束

  break
  num += 1
  continue的使用

  当循环语句执行到continue的时候，表示本次循环执行到此结束，然后可以继续下次循环

  提示: 只是结束了其中的一次循环，还可以继续下次循环

  容器类型
    Python容器类型：https://www.cnblogs.com/lyang-a/gallery/image/386555.html
  字符串
     字符串就是一串字符,是编程语言中表示文本的数据类型，通俗理解带有引号的数据认为是字符串
  字符串的表现形式:
     1、单引号字符串
     2、双引号字符串
     3、三个单引号字符串
     4、三个双引号字符串
  字符串使用说明:
     如果字符串的内容只有一行那么使用单引号或者双引号字符串都可以
     如果字符串的内容有多行数据，那么可以使用三引号字符串。
     提示： 多行注释本质上就是一个字符串。
  字符串的常用方法
     1、find：根据指定数据在字符串中获取该数据对应的下标，提示：如果没有返回-1，-1表示没有找到
     2、index：根据指定数据在字符串中获取该数据对应的下标，提示：如果查找的数据不存在，则程序崩溃
     3、count：根据指定数据统计该数据在字符串中出现的次数
     4、replace：替换字符串里面的指定数据
     5、split：根据指定数据对字符串进行分割
     6、join：对容器类型中的每一个数据进行字符串的拼接，返回一个新的字符串
     7、startswith：判断是否是以指定字符串开头
     8、endswith：判断是否是以指定字符串结尾
     9、strip：去除两边空白字符（空格，\n，\t）
     10、partition：根据指定数据把字符串分割成三部分
  下标和切片
  下标
     下标又称为索引，其实在程序里面就是一个数字，用于记录数据的位置。
     在Python中下标分为：
     正数下标：从0开始，从左到右取值
     负数下标：从-1开始，从右到左取值
  作用：根据下标获取容器类型中的某个数据
  下标的使用场景：
     像获取字符串、列表、元组中的某个数据时，则需要使用下标
  语法格式：
  result = 变量[下标]

  字符串结合下标使用，获取指定下标的数据

  my_str = "hello"
  result = my_str[-2]
  result = my_str[0]
  切片
     根据下标范围获取容器类型中的一部分数据，切片经常结合字符串、列表、元组一起使用，获取其中的一部分数据
  切片的语法格式:
     变量[开始下标:结束下标:步长]
      如果指定了结束下标，则结束下标不包含
      步长不指定默认是1

  根据切片获取前两个数据

  result = my_str[0:2:1] #=> [0,1]

  获取前两个数据的简写方式

  提示：步长不指定默认1，步长为正数表示从左往右取值

  提示：如果步长为正数，开始下标不指定，表示从第一个数据开始获取。

  result = my_str[:2]

  表示从倒数第三个一直获取到最后一个数据

  result = my_str[-3:]

  表示获取整个字符串数据，步长为正数的情况下，开始下标指定表示从一个开始获取，结束下标不指定表示获取到最后一个数据

  result = my_str[:]

  需求： 通过切片从倒数第一个获取到倒数第三个

  当步长是负数是，表示从右往左取值，也就是逆向取值

  result = my_str[-1:-4:-1]

  需求：字符串反转，从倒数第一个获取到正数第一个数据

  result = my_str[-1::-1]
  result = my_str[::-1]
  切片使用总结:
     1、使用切片的时候，先看步长，步长决定了取值方向
     2、当步长为正数，表示从左往右取值
     3、当步长为负数，表示从右往左取值
    注意：结束下标如果指定了则不包含结束下标对应的数据。
  列表
     就是一个容器类型，可以存储多个任意类型的数据，表现形式: []，类型是：list
  例：

  定义了一个列表，存储多个任意类型的数据

  my_list = [1, 3.14, 'hello', range(10), [1, 3, 4]]
  print(my_list, type(my_list))
  列表的遍历
     列表的遍历和字符串的遍历一样，都是循环获取每一个数据。
  for循环遍历列表:
  name_list = ["貂蝉", "西施", "王昭君", "杨玉环"]

  for遍历列表

  for value in name_list:

  倒着遍历每一个数据

  for value in name_list[::-1]:
  while循环遍历列表:

  while遍历列表

  index = 0

  获取列表的长度

  print(len(name_list))

  while index < len(name_list):

  print(index)

  根据下标获取对应的value

  value = name_list[index]
  print(index, value)
  index += 1
  列表的添加数据操作
     append()：往列表中追加指定数据
     insert()：根据指定下标插入数据
     extend()：往列表末尾扩展一组数据
  name_list = ["林冲", "晁盖", "吴用"]
  print(name_list , type(name_list))

  ==== append方法： 往列表中追加指定数据 ====

  name_list.append("鲁智深")
  print(name_list)

  ==== insert方法: 根据指定下标插入数据 =====

  name_list.insert(0, "宋江")

  ==== extend方法: 往列表末尾扩展一组数据 ====

  new_list = ["时迁", "杨雄", "石秀"]

  extend：把指定列表中的每一个元素追加到列表的末尾

  name_list.extend(new_list)
  列表的修改数据操作
  name_list = ['宋江', '林冲', '吴用', '鲁智深','杨雄', '石秀', '王伦']

  根据下标修改对应的数据

  name_list[0] = "及时雨宋江"
  name_list[-2] = "拼命三郎石秀"

  根据切片修改多个数据

  name_list[1:3] = ["豹子头林冲", "智多星吴用"]
  列表的删除数据操作
     del：根据下标删除数据
     pop()：根据下标删除数据并返回删除的数据
     remove()：根据列表中的元素删除数据
  name_list = ['宋江', '林冲', '吴用', '鲁智深', '石秀']

  ======= del: 根据下标删除数据 =======

  del name_list[-2]

  ======= pop: 根据下标删除数据并返回删除的数据 =======

  name = name_list.pop(1)
  print(name, name_list)

  pop方法如果不指定下标，默认删除的是倒数第一个

  name = name_list.pop()

  ======= remove: 根据列表中的元素删除数据 =======

  name_list.remove("吴用")
  列表结合in和not in使用
     in：判断指定数据在列表里面
     not in：判断指定数据不在列表里面
  hero_list = ['白起', '亚瑟', '关羽', '曹操']
  if '白起' in hero_list:
  print("白起在列表里面")
  if '张飞' not in hero_list:
  print("张飞不在列表里面")
  列表结合index和count方法的使用
     列表.index()：根据指定数据获取该数据在列表中的下标，如果在列表中不存在则崩溃
     列表.count()：根据指定数据统计该数据在列表中出现的次数
  my_list = ["A", "B", "C"]
  index = my_list.index("B")
  print(index)
  index = my_list.index("B", 0, 1)
  result = my_list.count("A")
  result = my_list.count("x")
  列表的排序和反转
     排序：列表.sort()，默认升序，从小到大排序
     反转：列表.reverse()，前后数据倒置
  my_list = [1, 0, 3, 2]
  print(my_list)

  提示：排序会在原有列表的基础上进行，不需要使用变量保存排序后的结果

  my_list.sort()
  print("排序后的列表数据为:", my_list)

  排序后再进行反转, 提示：列表反转也会在原有列表的基础上进行的，不会返回一个新的列表，所以不需要使用变量保存

  my_list.reverse()
  print("反转后的数据为:", my_list)

  直接对列表中的数据进行降序排列

  my_list.sort(reverse=True) # 先排序然后再反转
  列表嵌套
     在一个列表里面再次使用一个列表，该格式称为列表嵌套
  city_list = [['广州', '深圳'], ['北京', '西安']]

  1. 获取北京所在的小列表

  north_city_list = city_list[1]
  print(north_city_list)

  2. 根据北京的这个小列表获取北京这个数据

  city_name = north_city_list[0]
  print(city_name)

  3. 以上两行代码可以合并来写

  city_name = city_list[1][0]
  元组
     是一个容器类型，可以存储多个数据。元组只能进行读取，不能进行增删改。类型是：tuple
    注意：元组里面只有一个数据时，后面的逗号不能省略
    使用场景：字符串格式化输出

  定义一个元祖

  name_tuple = ('宋江', '林冲', '吴用', '鲁智深', '石秀')
  print(name_tuple, type(name_tuple))
  元组的遍历
  for循环遍历:

  for循环遍历元组

  for value in name_tuple:
  while循环遍历:

  while循环遍历元组

  while index < len(name_tuple):
  value = name_tuple[index]
  字典
     是一个容器类型，字典中的每个数据都是一个键值对，字典中key是唯一。
     字典的表现形式: {key1: value1, key2: value2, ...}，类型: dict
     字典的使用场景：当存储某一个描述性信息的时候，可以使用字典，比如：存储一个学生信息

  定义字典类型的变量

  person_dict = {"name": "张三", "age": 23, "sex": "男", "address": "武汉"}
  print(person_dict, type(person_dict))
  字典的取值操作
     使用 [] 中括号 方式取值，使用中括号方式取值，如果key不存在则程序崩溃
     使用 get() 方法的方式取值，如果key不存在程序不会崩溃，会返回一个空值(None)，取值比较安全
  person_info = {"name": "杨紫", "sex": "女", "age": 29}
  name = person_info["name"]
  print(name)
  age = person_info.get("age")
  print(age)

  使用中括号方式取值，如果key不存在则程序崩溃

  address = person_info["address"]
  print(address)

  使用get方式取值的时候，如果key不存在程序不会崩溃，会返回一个空值(None)

  address = person_info.get("address")

  get方式取值还可以设置默认值。

  address = person_info.get("address", "北京")
  字典的增删改操作
  person_dict = {"name": "张三", "age": 23, "sex": "男"}
  print(person_dict)

  往字典中添加一下数据, 注意：需要保证操作的key在字典中不存在

  person_dict["address"] = "北京"

  修改字典中的value值，注意：需要保存操作的key在字典中存在

  person_dict["age"] = 35

  删除字段中某项数据，根据key删除

  del person_dict["sex"]
  name = person_dict.pop("name")
  print(name, person_dict)

  清空字典数据

  person_dict.clear()
  字典的合并

  字典数据合并

  my_person = {"name": "张三", "age": 20, "sex": "女"}
  my_per = {"address": "武汉", "sex": "男"}
  my_person.update(my_per)
  print(my_person)
  字典的常见操作
     len函数: 获取容器类型中元素的个数
     dict.keys()：获取字典中的所有key
     dict.values()：获取字典中的所有value
     dict.items()：获取字典中的所有项数据
  my_person = {"name": "张三", "age": 20, "height": 1.70, "sex": "男"}
  print("字典的长度为：", len(my_person))
  key = my_person.keys()
  print("获取字典中所有的key:", key)
  value = my_person.values()
  print("获取字典中所有的value:", value)
  item = my_person.items()
  print("获取字典中所有的数据项:", item)
  字典的遍历
  遍历字典中的每一个key
  遍历字典中的每一个value
  遍历字典中的每一项数据
  遍历字典中每项数据的key和value

  遍历字典中所有的键

  提示：直接对字典进行遍历默认遍历的是key

  for key in my_person:
  print(key)
  for key in my_person.keys():

  遍历字典中所有的值

  for value in my_person.values():

  根据字典中的键遍历所有的值

  print(my_person[key])

  遍历字典中所有的数据项

  for item in my_person.items():
  print(item)

  遍历字典中所有的数据项,根据数据项获取对应的键和值

  key = item[0]
  value = item[1]
  print(key, value)

遍历字典中的每项数据的key和value简写方式

for key, value in my_person.items():
集合
   集合也是一个容器类型，可以存储多个数据，但是数据不能重复，存储的数据是唯一，而且集合中的数据是无序
   集合的表现形式：{1, 3, 5} ，类型：set
  注意点：
   1、不能根据下标获取或者修改数据, 它可以添加和删除数据
   2、创建一个空的集合不能使用 {}，因为{} 表示字典类型，需使用 set() 进行创建
my_set = {1, 3, 'a'}
print(my_set, type(my_set))

往集合里面添加一个数据

my_set.add("c")

删除集合中的数据

my_set.remove(1)

set()表示创建空的集合 ， list() 表示创建空的列表

my_set = set() # {}
对集合进行遍历
   提示：集合不能使用while循环进行遍历，因为集合不支持下标取值。
my_set = {'a', 1, 'b', 2}

想要获取集合中的每一个数据，可以通过for遍历

for value in my_set:
集合的去重操作
   把容器类型转成集合类型即可完成去重效果
  总结：
   1、集合可以对列表和元组中的数据进行去重
   2、列表、元组、集合它们三者之间可以相互进行类型转换
my_list = ['A', 'A', 'A', 'B', 'B', 'C', 'D', 'D']
my_set = set(my_list)
my_tuple = (1, 3, 1, 3, 1, 'a')
my_set = set(my_tuple)
print("把元组转成集合:", my_set, type(my_set))
my_tuple = tuple(my_set)
print("把集合转成元组:", my_tuple, type(my_tuple))
my_list = list(my_tuple)
print("把元组转成列表:", my_list, type(my_list))
公共的运算符
   + 结合容器类型使用，是用于完成数据合并或者拼接，支持的类型有：字符串，列表，元组
   结合容器类型使用，用于对容器类型中的数据进行复制，支持的类型有：字符串，列表，元组
my_str1 = 'abc'
my_str2 = 'bcd'
new_str = my_str1 + my_str2
print("字符串之间进行数据拼接：", new_str)
my_list1 = [1, 3, 5]
my_list2 = [2, 4, 6]
new_list = my_list1 + my_list2
print("列表之间进行数据拼接：", new_list)
my_tuple1 = (1, 2, 3)
my_tuple2 = (4, 5, 6)
new_tuple = my_tuple1 + my_tuple2
print("元组之间进行数据拼接：", new_tuple)
my_str = "ABC" 3
print(my_str)
my_list = [[1, 3, 'a']] * 3
my_list = [1, 7, 4]
print(len(my_list))
print(min(my_list))
print(max(my_list))
my_set = {1, 7, 4}
print(len(my_set))
print(min(my_set))
print(max(my_set))
公共的关键字
   in 主要是结合容器类型使用，判断数据在某个容器类型里面，支持的类型有: 字符串，列表，元组，字典，集合
   not in 主要是结合容器类型使用，判断数据不在某个容器类型里面，支持的类型有: 字符串，列表，元组，字典，集合

字符串

print("====字符串====")
my_str = "Hello Python"
flag_str = "he" in my_str
print(flag_str)
flag_str = "he" not in my_str

列表

print("====列表====")
my_list = [1, 2, 'a']
flag_list = "a" in my_list
print(flag_list)
flag_list = "a" not in my_list

元组

print("====元组====")
my_tuple = (1, 3, 5)
flag_tuple = 3 in my_tuple
print(flag_tuple)
flag_tuple = 1 not in my_tuple

字典

print("====字典====")
my_dict = {"name": "张三", "age": 18}
flag_dict = "name" in my_dict
print(flag_dict)
flag_dict = "name" not in my_dict

集合

print("====集合====")
my_set = {1, 2, 3, 'a'}
flag_set = "a" in my_set
print(flag_set)
flag_set = "a" not in my_set
Python提供的内置函数
  内置函数：不需要导入模块或者包直接使用的函数称为内置函数
   len()：统计容器类型中元素的个数
   max()：获取容器类型中的最大值
   min()：获取容器类型中的最小值
person_dict = {"name": "李四", "age": 30}
result = len(person_dict)
print("字典中键值对的个数为:", result)
my_list = [0, -1, 3]
max_value = max(my_list)
print("最大值:", max_value)
min_value = min(my_list)
print("最小值:", min_value)
推导式
   推导式 comprehensions（又称解析式），是 python 的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列。
列表推导式
语法：
变量名 = [表达式 for 变量 in 列表 if 条件]
变量名 = [表达式 for 变量 in 列表 for 变量 in xxx]

创建一个包含元素1-10的列表

list1 = [i for i in range(1, 11)]
print(list1)
字典推导式
   字典推导式列表推导式思想的延续，语法差不多，只不过产生的是字典而已。
   字典推导式格式：
{ key_expr: value_expr for value in collection if condition }

将字典中的 key 和 value 进行对换。

mcase = {'a': 10, 'b': 34}
mcase_frequency = {v: k for k, v in mcase.items()}
print(mcase_frequency)
集合推导式
   集合推导式跟列表推导式非常相似，唯一区别在于用 { } 代替 [ ]
  例：

创建一个存储10个偶数的集合

my_set = {x for x in range(10) if x % 2 == 0}
print(my_set)
函数
   实现某个功能的代码段（一段功能代码）
   作用：提高功能代码的复用性，减少功能代码的冗余。
函数的定义和调用
不带参数的函数
定义函数的语法格式:
def 函数名():
编写实现某个功能的代码
调用函数:
函数名()

定义函数

def show_info():

# 提示：如果变量的数据不需要使用，则使用下划线进行替换即可，表示该数据不使用。
    print("好好学习!")

对函数进行调用

show_info()
带有参数的函数
定义带有参数的函数的语法格式:
def 函数名(形参1, 形参2, ...):
实现相关的功能
   形参：在定义函数时设置参数称为形参
带有参数的函数:
函数名(实参1, 实参2, ...)
   实参：在调用函数时设置参数称为实参

定义带有两个参数的函数

def sum_num(num1, num2):
print("结果为:", num1 + num2)

调用带有参数的函数

sum_num(1, 2)
带有返回值的函数
   函数想要带有返回值，只需要在函数内部使用return加上要返回的数据即可
   返回值：就是函数调用完成后，最后给调用者的结果。
   说明：当调用带有返回值的函数的时候，需要使用变量保存函数调用后返回的结果。
def 函数名(形参[可选]):
return 数据
调用带有返回值的函数的语法格式:
result = 函数名(实参[可选])
def sum_num(n1, n2):
result = n1 + n2

# 这里的写法，表示函数带有返回值
return result

定义了一个变量，名字是value，保存的是函数调用后返回的结果

value = sum_num(1, 2)
print("获取到的返回值是:", value)
局部变量与全局变量
局部变量
   在函数里面定义的变量
  作用域：只能在当前函数内使用，不能在函数外或者其它函数内使用
  提示：局部变量用于临时存储函数内的数据，当函数执行结束后，局部变量保存的数据也会销毁

局部变量

def send_msg(msg):
data = f"您发送的数据为：{msg}"
send_msg("你好")
全局变量
   在函数外定义的变量
  作用域：可以在不同函数或者函数外使用，也就是在整个Python文件中都可以使用
  作用： 全局变量可以在不同函数之间共享数据

定义全局变量

g_score = 99
def show_score():
print("在函数show_score内使用全局变量，该数据为:", g_score)
def show_data():
print("在函数show_data内使用全局变量，该数据为:", g_score)
show_score()
show_data()
print("函数外使用全局变量:", g_score)
在函数内修改全局变量
  在函数内修改全局变量，需要加上 global关键字 进行声明，表示要修改全局变量。

全局变量

value = 10
def modify_global_value(val):

# 修改全局变量，需要在变量名前加上 global 关键字
global value
value = f"{val}"

print("修改之前的值为：", value)
modify_global_value(20)
print("修改之后的值为：", value)
return关键字
   当函数执行完return语句后，表示函数执行结束，return后面的代码不会执行
   多次return语句只能返回第1次return的数据
  提示：函数想要返回多个数据，可以借助容器这个数据类型，比如返回一个元组，列表，字典。
def return_more_value():

# 返回元组
# return 1, 2
# 返回列表
# return [1, 2]
# 返回字典
return {"k1": 1, "k2": 2}

value = return_more_value()
print(value, type(value))

例：当循环的值等于5时，跳出循环

def loop_value():
for value1 in range(4):
print("外层循环的数据为:", value1)
for value2 in range(10):
print("内层循环的数据为:", value2)

        # 当内层循环等于5时，让两个循环都结束
        if value2 == 5:
            return

loop_value()
调用函数时的传参方式
按照位置参数的方式进行传参
   注意：位置参数的顺序一定要和形参的顺序保持一致
按照关键字参数的方式进行传参
   注意：关键字参数的名字一定要和形参的名字保持一致。
按照复合参数（前面使用位置参数后面使用关键字参数）的方式进行传参
def person(name, age, sex):
print(f"姓名：{name} 年龄：{age} 性别：{sex}")
person("白起", 30, "男")
person(name="貂蝉", age=18, sex="女")
person("曹操", age=20, sex="男")
函数的缺省参数
   在定义函数时，给形参设置了默认值，该形参称为缺省参数
缺省参数的特点：
   当调用函数时，如果给缺省参数传值，则使用输入的数据
   当调用函数时，如果没有给缺省参数传值，则使用默认值
  注意：缺省参数后面不能再有普通的形参，缺省参数后面还可以在定义缺省参数。
示例：
def sum_num(num1, num2=10, num3=20): # 此时num2=10，num2就是缺省参数
result = num1 + num2

调用函数，保存返回的结果

value = sum_num(1, 1)

print("结果为:", value)

value = sum_num(1)
print("结果为:", value)
函数的不定长参数
   在定义函数的时候，不确定接收参数的个数，那么此时定义的参数称为不定长参数
不定长参数的表现形式:
   args：表示不定长位置参数，职责：专门负责接收不确定个数的位置参数
   *kwargs：表示不定长关键字参数，职责: 专门负责接收不确定个数的关键字参数

定义一个函数，带有不定长位置参数和不定长关键字参数

def info(args, **kwargs):
print("args", args, type(args))
print("kwargs", kwargs, type(kwargs), "\n")
info(a=1, b=2)
info(1, 3, a=2, b=4)
info(1, 3, a=2, b=4, c=[3, 6, 9], d={"name": "张三", "age": 20})
元组中的数据按照位置参数的方式进行传参
   把容器中每一个数据按照位置参数的方式进行传参，比如：列表、字典、集合
   语法：数据
def show_info(name, age):
print(name, age)
person_info = ('张三', 20)

把元组中的每个数据按照位置参数的方式进行传参

show_info(person_info)
字典中的数据按照关键参数的方式进行传参
   把字典中的每项数据按照关键字参数的方式进行传参
   语法：*数据，数据必须字典类型
person_info = {"name": "李四", "age": 20}

把字典按照关键字的方式进行传参

show_info(**person_info) # => show_info(name="李四", age=20)
拆包
   使用不同变量来保存容器类型中的每一个数据的操作称为拆包
  提示：拆包是针对的是容器类型（字符串，列表，元组，字典，集合，range）

对字符串进行拆包

v1, v2, v3 = "abc"
print(v1, v2, v3)

对元组进行拆包

data1, data2 = (1, 2)
print(data1, data2)

对字典进行拆包

my_dict = {"name": "李四", "age": 20}
name, age = my_dict.values()
print(name, age)

对随机数进行拆包

v1, v2 = range(2, 5, 2)
print(v1, v2)

对集合进行拆包

v1, v2, v3 = {'c', 'd', 3}
def return_data():
return "张三", 30

利用拆包，获取每一个数据

name, age = return_data()
交互两个变量的值
  拆包交换两个变量的值，背后的原理
   1、把两个变量的值进行组包，放到一个元组里面
   2、利用拆包分别保存元组里面的每一个数据
num1 = 10
num2 = 20

让num1保存元组里面的第一个数据，让num2保存元组中的第二个数据

num1, num2 = num2, num1
print("num1: {} num2: {}".format(num1, num2))
lambda表达式（匿名函数）
​ lambda 表达式，又称匿名函数，常用来表示内部仅包含 1 行表达式的函数。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。
name = lambda [list]: 表达式
  其中，定义 lambda 表达式，必须使用 lambda 关键字；[list] 作为可选参数，等同于定义函数是指定的参数列表；value 为该表达式的名称。
  求 2 个数之和
sum = lambda x, y: x + y
print(sum(3, 2))

或

def calc(sum):
num1 = int(input("请输入第一个整数:"))
num2 = int(input("请输入第二个整数:"))
return sum(num1, num2)
result = calc(lambda x, y: x + y)
文件
  持久化存储的方式:
   文件存储： 少量数据适合使用文件存储
   数据库存储: 大量数据适合使用数据库存储，因为数据库读写性能极高。
文件读取
   说明：r 表示以字符串的方式读取文件中的数据
   注意：当使用 r模式 的时候，需要保证文件必须存在，否则文件不存在则程序崩溃

1. 打开文件，指定模式，指定编码格式

file = open("test.txt", "r", encoding="utf-8")

在windows系统下，使用open打开文件默认使用的是gbk, CP936其实就是GBK

在mac和linux系统下，使用open打开文件默认使用的是utf-8

print(file.encoding)

2. 读取文件中的数据

data = file.read() # read()：读取文件中的所有数据
print(data, type(data))

3. 关闭文件

file.close()
文件写入
   说明：w 表示以字符串的方式往文件中写入数据
   注意:
   当文件的操作模式是w模式时，打开文件不存在则创建一个空的文件，然后再写入数据
   当文件的操作模式是w模式时，打开文件存在则会清空原文件中的数据，然后再写入新的数据。
file = open("test.txt", "w", encoding="utf-8")

2. 写入数据到文件

file.write("人生苦短\n")
file.write("我用Python\n")
文件追加写入
   说明：a 表示以字符串的方式往文件中追加写入数据
   当文件的操作模式是a模式时，打开文件不存在时会创建一个空的文件，然后再写入数据
   当文件的操作模式是a模式时，打开文件存在则会在原有数据的基础上追加写入，不会对之前的数据进行清除。
file = open("test.txt", "a", encoding="utf-8")
file.write("\n我是追加的数据，，，")
file.write("\n人生苦短，我用Python")
readline()和readlines()方法的使用
   readline()：读取一行数据，默认是从第一行读取
   readlines()：读取文件中的所有行数据，返回一个列表
readline()方法的示例：

读取第一行数据

data = data.readline()
print(data)
data.close()
readlines()方法的示例：

读取数据

result = file.readlines()

把每行数据的\n去掉再保存到一个新的列表里面

data_list = [row.strip() for row in result]
print(data_list)

遍历每行数据

for row in data_list:
print(row)
print("==" * 10)

获取第一行

first_line = data_list[0]
print(first_line)

获取最后一行

last_line = data_list[-1]
print(last_line)

获取最后两行数据

result = data_list[-2:]

关闭文件

面向对象
   面向过程：实现某个功能，自己亲力亲为，需要关心实现的步骤和过程，程序员好比是执行者的角色，也就是以面向函数的方式进行开发。
   面向对象：实现某个功能，需要找一个合适对象，比如：找一个合适的人或者物，让它来帮我们来实现，自己不需要关心实现的步骤和过程，只关心能否帮我们做对应的事情，程序员好比是设计者的角色。
类和对象
类（class）
   类是对一系列具有相同特征和行为的事物的统称，好比现实生活中事或者物的一个分类，比如：人类、狗类、猫类
   特征即是属性
   行为即是方法
对象
   对象是由类创造出来的，能够具体到的某一个事或者物都可以称为对象。
类和对象的关系
   先有类，再有对象，类是创建对象的一个模板
类的构成
  类(Class) 由3个部分构成：
   类的名称：类名
   类的属性：这类事物具有的特征
   类的方法：这类事物具有的行为
  举例：
   人类设计:
   类名：人(Person)
   属性：身高(height)、年龄(age)
   方法：跑(run)、跳舞(dance)、唱歌(sing)
定义类和创建对象
定义类
   定义类需要使用class关键字
class 类名:
属性和方法
class Dog:

# 吃的方法
def eat(self):
    print("小狗正在吃食物，，，")

# 睡觉的方法
def sleep(self):
    print("小狗正在睡觉。。。")

  注意：定义类的时候类名要使用大驼峰
创建对象
   定义好的类可以创建出一个或多个对象
创建对象的格式：
对象名1 = 类名()
对象名2 = 类名()

创建自定义类的对象

dog1 = Dog()
print("dog1:", dog1)
dog2 = Dog()
print("dog2:", dog1)
  提示: 不仅可以使用自定义的类创建对象，系统的类也可以创建对象，比如: 列表、字符串、元组这些类型都可以创建对象，只需要通过类名()即可
  在python中我们直接使用的一个具体数据也可以称为对象，比如："aaa"、["1", "2"]，它们分别是一个字符串对象和一个列表对象。
使用 self 获取对象的属性
self 说明:
   self表示调用当前方法时的对象
   在方法内获取不同对象的属性信息，可以通过self来完成。
   1、在类内部获取 属性 和 调用实例方法，通过self来完成；
   2、在类外部获取 属性 和 调用实例方法，通过对象名来完成。
class Person:

# __init__ ：给对象进行初始化的方法，当创建对象后会自动调用此方法
def __init__(self, name, age, sex):
    self.name = name
    self.age = age
    self.sex = sex
# __str__ ：用于描述对象返回的信息，当输出对象的时候回自动调用此方法
def __str__(self):
    return f"姓名：{self.name}  年龄：{self.age}  性别：{self.sex}"

per = Person("张三", 18, "男")
print(per)
初始化方法的 缺省参数 使用
   缺省参数：给参数设置默认值，如果对应的参数不传值的话（不会报错），则使用默认设置的参数。
class Hero:

# age=18, sex="男" ：设置缺省参数，不传值则使用默认设置的值
def __init__(self, name, age=18, sex="男"):

hero1 = Hero("白起")
print(hero1)

按照位置参数的方式进行传参

hero2 = Hero("花木兰", 19, "女")
print(hero2)

按照复合参数的方式进行传参

hero3 = Hero(name="关羽", age=23, sex="男")
print(hero3)

按照关键字参数的方式进行传参

hero4 = Hero("曹操", age=30, sex="男")
print(hero4)
hero_info = ("夏侯惇", 20, "男")

把元组中的每一个数据按照位置参数的方式进行传参

hero5 = Hero(hero_info)
print(hero5)
person_info = {"name": "瑶", "age": 17, "sex": "女"}
hero6 = Hero(*person_info)
print(hero6)
实例属性和类属性
实例属性
   实例属性又称为对象属性，在 init 方法里面定义的属性称为实例对象，实例属性是属于某个对象。
   注意：实例属性的操作需要通过实例来完成，不要通过类来完成。
  
dict属性的说明:
对象.dict：以字典形式获取对象的属性信息
类.dict：以字典形式获取类的成员信息
类属性
   在类里面和方法外面定义的属性称为类属性，类属性是属于当前类。
   注意：类属性的操作需要由类来完成，不要使用对象来完成。

# 类属性
country = "中国"
def __init__(self, name, age):
    # 在init方法里面添加的属性都是实例(对象)属性
    return "姓名：{} 年龄：{}".format(self.name, self.age)

实例的属性的操作

p = Person("张三", 20)
print("修改前:", p.name)

使用对象修改实例属性

p.name = "张三丰"
print("修改后:", p.name)
print("===============" * 2)

以字典形式查看对象的属性信息

print("对象的属性信息:", p.dict)

添加属性信息

p.sex = "男"

以字典形式查看类的成员信息，包括类属性和方法

print("类的成员有:", Person.dict)

使用类访问类属性

country = Person.country
print(country)
print("修改前对象的属性信息:", p.dict)
print("修改前类的成员有:", Person.dict)

修改国家信息

Person.country = "美国"
print("修改后对象的属性信息:", p.dict)
print("修改后类的成员有:", Person.dict)

注意：对象可以访问类属性，但是不能修改

这里不是修改类属性，而是添加对象属性

print("对象访问类属性:", p.country)
总结：
   实例属性的操作不管是获取实例属性还是修改示例属性都是有实例(对象)来完成的，不要用类。
   类属性的操作都需要使用类来完成，只不过对象可以访问类属性，但是不能修改
类方法和静态方法
  在Python中，类里面可以定义三种方法，分别是：
实例方法
类方法
静态方法
  实例方法也可以称为对象方法
  实例方法的表现形式：
   方法的第一个参数是 self，那么这样的方法称为实例方法

# 修改年龄的方法
def set_age(self, new_age):
    if 0 <= new_age < 130:
        self.age = new_age
    else:
        print("对不起，请设置合法年龄!(0-130)")
# 获取实例属性的年龄
def get_age(self):
    return self.age

per = Person("王五", 20)
print("修改前的信息:", per.name, per.age)

修改年龄

per.set_age(40)
print("修改后的信息:", per.name, per.age)

获取年龄

age = per.get_age()
  类方法的表现形式：
   方法的第一个参数是 cls 并且在方法名字上面还需要使用 @classmethod 关键字进行修饰，那么这样的方法称为类方法
city = "北京"

# 类方法
@classmethod
def set_city(cls, new_city):
    if new_city in ["武汉", "广东", "深圳", "上海"]:
        cls.city = new_city
def get_city(cls):
    return cls.city

print(Person.city)

访问类方法

Person.set_city("深圳")
print(Person.get_city())
  静态方法的表现形式：
   方法的参数没有self和cls并且在方法名字上面还需要使用 @staticmethod 关键字进行修饰，那么这样的方法称为静态方法
class ClassMethod:

# 静态方法
@staticmethod
def show_info():
    # 因为当前方法内不需要使用self和cls参数则定义成静态方法即可
    print("我是一个静态方法！")
# 静态方法，设置两个数相加
def sum(num1, num2):
    return num1 + num2

类访问静态方法

ClassMethod.show_info()

对象访问静态方法

cla = ClassMethod()
cla.show_info()
sum = ClassMethod.sum(2, 3)
print(sum)
继承
   是一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
   通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
   父类：也称为基类
   子类：也称为派生类
继承语法：
class 派生类名(基类名)
自己的属性和方法
class Animal:
print(f"{self.name}吃食物")

子类Dog继承了Animal，可以使用Animal类里面的属性和方法

class Dog(Animal):
def watch_door(self):
print(f"{self.name}正在看门")
dog = Dog("大黄", 1)
print(dog.name, dog.age)
dog.eat()
dog.watch_door()
重写
   重写有时又称覆盖，子类继承父类，对父类的功能方法进行修改
重写的条件
   1、要有继承关系
   2、子类的方法名和父类的方法要一样
class Bird:

#鸟有翅膀
def isWing(self):
    print("鸟有翅膀")
#鸟会飞
def fly(self):
    print("鸟会飞")

class Ostrich(Bird):

# 重写Bird类的fly()方法
    print("鸵鸟不会飞")

创建Ostrich对象

ostrich = Ostrich()

调用 Ostrich 类中重写的 fly() 类方法

ostrich.fly()
super()函数
   super()函数：调用父类的构造方法
def work(self):
print("每个人都要进行工作")
class Student(Person):
def init(self, student_no, name, age):

    # super 表示父类，调用父类提供的方法
    #         1. 指定当前类，表示寻找那个子类的父类
    #         2. 指定对象，表示给那个对象添加属性
    # 调用父类中的init方法
    super(Student, self).__init__(name, age)
    # 自己添加属性
    self.student_no = student_no
    # 先显示父类提供的功能
    super(Student, self).work()
    # 再显示子类特殊的功能
    print("而学生的工作就是要好好学习")

stu = Student(1, "小明", 18)
stu.work()
异常
   当python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的 ”异常“
捕获异常
   捕获异常的目的：保存程序能够正常运行, 程序不崩溃。
try:
执行可能出现异常的Python代码
except Exception as e:
捕获异常
说明:
Exception 常规异常的基类，比如: NameError(变量名错误)就是它的子类
e：表示异常类的对象
num = int(input("请输入一个数字："))
print('输入不合法，请输入整数数字！')
异常处理的完整写法
   try：表示尝试执行可能出现异常的代码
   except：捕获异常，对异常进行处理
   else：表示没有异常，会执行else语句
   finally：表示有没有异常都会执行finally
执行可能出现异常的代码
捕获异常，对异常进行处理
没有异常，会执行else语句
finally:
表示有没有异常都会执行finally语句
示例代码：
num = int(input("请输入一个整数:"))
print("您输入的整数为:", num)

# 输出异常对象的错误信息
print("请输入一个正确的整数!", e)
print("整数没有问题，通过")
print("有没有异常，哥必须执行")

模块
   模块就是 Python 程序（文件）。任何 Python 程序都可以作为模块，包括在前面章节中写的所有 Python 程序，都可以作为模块。
  模块的作用：
   用来管理不同的功能代码的，功能代码指的就是函数，类，全局变量，匿名函数等
  模块名的组成：
   模块名的组成和变量名的组成一样，都是由字母、数字、下划线组成，但是不能以数字开头
  提示：
   如果模块名以数字开头了，只能自己使用，不能被其他模块导入使用
模块的导入
   import 模块名
   from 模块名 import 功能代码(函数，类等)
导入模块的注意点：
   自制模块名不要和系统的模块名同名。
   导入模块时默认是在当前工程目录下查找的，优先使用自己的创建的Python文件
测试模块是否是主模块
   如果输出 name 得到的结果为 main 则为主模块；如果得到的是 自定义的模块名 则说明不是主模块
  calc模块
return num1 + num2
print("calc:", name)
if name == 'main':
sum = sum_num(2, 3)
print("结果为：", sum)
//代码效果参考：http://www.ezhiqi.com/zx/art_6980.html

sum模块

导入模块

import calc
from calc import sum_num
print("sum:", name)
sum = calc.sum_num(3, 5)
print("两数之和为：", sum)
print(sum_num(3, 6))
  结果:
calc: calc
sum: main
两数之和为： 8
9
包
   通俗理解就是一个文件夹里面必须存在一个名为 init.py 的文件。
   每个包的目录下都必须建立一个 init.py 的模块，可以是一个空模块，可以写一些初始化代码，其作用就是告诉 Python 要将该目录当成包来处理。
包的作用：
   包是用来管理不同模块的
包的命名规则：
   由字母、数字、下划线组成，但是不能以数字开头
包的导入
   import 包名.模块名
   from 包名 import 模块名
   from 包名.模块名 import 功能代码
  init.py 示例代码：
num = 100
//代码效果参考：http://www.ezhiqi.com/bx/art_3527.html

  recv_msg.py 示例代码：
def recv_data():
print("正在接收数据!")
  send_msg.py 示例代码：
def send_data():
print("正在发送数据")
导包操作示例代码：
print("============= import 包名.模块名 =============")
import first_package.recv_msg
import first_package.send_msg
first_package.recv_msg.recv_data()
first_package.send_msg.send_data()
print("============= from 包名 import 模块名 =============")
from first_package import recv_msg
from first_package import send_msg
recv_msg.recv_data()
send_msg.send_data()
print("============= from 包名 import 模块名 as 模块别名 =============")
from first_package import recv_msg as rm
from first_package import send_msg as sm
rm.recv_data()
//代码效果参考：http://www.ezhiqi.com/zx/art_5134.html

sm.send_data()
print("============= from 包名.模块名 import 功能代码 =============")
from first_package.recv_msg import recv_data
from first_package.send_msg import send_data
recv_data()
send_data()
print("============= from 包名 =============")

直接导入包，默认只能使用 init.py 中的功能代码

import first_package
num = first_package.num1
print(num)