第一章 Python简介

1. Python起源

  • 「Python」是由 吉多 在1989年发明的一个解释程序
  • 「Python」的中文意思是 ：蟒蛇
  • 「Python」是一门解释型语言，无需编译
  • 一般情况下，开发相同功能，「Python」的代码量是「java」的「1/5」左右
  • 现有版本：
    • 「Python2」：最初发布于2001年
    • 「Python3」：最初发布于2008年，最新的版本
  • 格言：Life is short ,you need Python!（人生苦短，我用Python！）

    吉多范罗苏姆

03 | Python编程基础 - 图1

2. Python的应用

  • 云计算：云服务器
  • web开发：豆瓣，知乎，YouTube
  • 人工智能：语音助手，用户行为分析
  • 自动化测试：编写自动化测试脚本

    附云服务器管理界面图片
    03 | Python编程基础 - 图2

3. Python的优势

  • 开源，免费
  • 易学
  • 可移植性强（windows，Linux，MacOs）

  • 丰富的库

    第二章 安装Python

    1. 下载Python安装包

  • 进入官方网站：https://www.python.org

  • 点击Download，选择Windows系统版本，下载带有 Windows，64，exe 字眼的安装包

    2. 安装

    2.1 安装

    03 | Python编程基础 - 图3

    2.2 验证Python

  • 打开命令行窗口，输入：「Python」

  • 如能看到「Python」版本号，表示安装成功
  • 如果提示「Python不是内部或外部命令」，则需要手动配置环境变量，在系统变量path中添加如下路径
    1. C:\Python38\Scripts\;C:\Python38\

    2.3 第一个Python程序

    在Python交互模式中输入：
    1. print("Helloworld")
    这行代码的意思是：在屏幕上打印“你好世界”

    3. 设置国内下载源

    pip默认使用国外安装源，导致安装其他包时，下载速度过慢或者出错
    所以，推荐使用国内安装源

python官方源：https://pypi.org 清华：https://pypi.tuna.tsinghua.edu.cn/simple 阿里云：http://mirrors.aliyun.com/pypi/simple/ 中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/ 华中理工大学：http://pypi.hustunique.com/ 山东理工大学：http://pypi.sdutlinux.org/ 豆瓣：http://pypi.douban.com/simple/

解决办法1（临时）：

  1. # 在下载时临时指定安装源
  2. pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名

解决办法2（永久）：

  1. Windows
  2. 1.新建一个pip目录：C：\user\xxx\pip
  3. 2.新建一个pip.ini
  4. # 内容如下
  5. [global]
  6. index-url = https://pypi.tuna.tsinghua.edu.cn/simple
  7. [install]
  8. trusted-host=mirrors.aliyun.com

4. pip导出所有模块

  1. pip freeze>D:\requirements.txt

第三章 安装Pycharm

1. 下载pycharm安装包

  • 进入官网：https://www.jetbrains.com/pycharm/
  • 下载Community版本，社区版，免费

    2. 创建项目

    image.png

    3. 基本布局

    image.png

    4. 新建Python文件

    image.png

    5. 设置字体

    image.png

    6. 配置解释器

    在pycharm中一定要配置好自己安装的「Python」环境的解释器，不然后续自己安装的其他模块将无法使用
    03 | Python编程基础 - 图8

7. 设置快捷键

设置运行代码快捷键
image.png

第四章 注释

1. 定义

  • 注释是用来解释说明代码的作用的

  • 注释不会被执行

    2. 单行注释

  • 单行注释用 # 表示

  • 单行注释只在一行内生效，可以顶行写，也可以写在代码后面

    3. 多行注释

  • 多行注释用 一对三单引号/双引 号示

  • 多行注释有特殊用途（文档注释）

    4. 快速注释快捷键

  • 按一次 Ctrl + / 快速注释

  • 再按一次，取消注释

    5. 关于编码规范


    Python PEP 8规范中文版本地址：https://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/

    第五章 基础数据类型

    在真正开始写程序之前，你要知道程序的作用是什么？

程序真正的作用是 处理数据 。数据的种类有很多，我们在手机、电脑等其他设备行看到的文字、数字、音视频等都是数据。
这些数据都是由程序来处理并显示到屏幕上的。
虽然数据的中类形形色色，并且看起来比较复杂，但是在编程时，他们实际上都是由一些非常基本的数据形式（或经过组合）来表示。
在Python中，基本的数据类型有如下这些：

  1. # 整数  int
  2. # 可以使用type去查看数据的类型
  3. print(type(0))
  4. print(type(-1))
  5. print(type(3))
  7. # 浮点数  float
  8. print(type(0.0))
  9. print(type(-0.1))
  10. print(type(0.1))
  12. # 字符串  string  str
  13. print(type("x"))
  14. print(type(""))   # 空字符串
  15. print(type(''))   # 单引号也可以 "i'm ok"
  17. # 布尔值  bool
  18. print(type(True))  # 真
  19. print(type(False))  # 假
  21. # 空值  None
  22. print(type(None))   # None!=0  用来占位

第六章 变量

1. 定义

  • 变量是一个容器，里面可以存 任意类型 的数据
  • 变量的实质是储存在 内存中 的值

  • 变量定义好以后，可以通过变量名重复使用

    2. 变量的命名规范

    「规范」：

  • 只能由数字、字母、下划线组成

  • 不能以数字开头
  • 不能使用系统关键字
  • 区分大小写

「推荐的变量命名方式」：

  • 见名知意，使用具有固定意义的单词
  • 驼峰命名法
    • 大驼峰：每个单词首字母都要大写（FirstLove）
    • 小驼峰：从第二个单词开始，首字母大写（firstLove）
  • 使用下划线连接：first_love

    3. 变量的赋值方式

    3.1 普通赋值

    将右边的值给左边的变量：a = 1

    3.2 序列解包赋值

    在一行代码中同时给多个变量赋值，按照位置关系对应：a，b = 1，2

    3.3 链式赋值

    在一行代码中同时给多个变量赋同一个值：a = b = c = 1

    如何查看系统关键字？

  1. import keyword   # 导包
  3. print(keyword.kwlist)   # 打印系统关键字

第七章 运算符

1. 基础运算符

运算符 描述 实例
+ 加 10 + 20 = 30，还可以进行字符串拼接
- 减 10 - 20 = -10
* 乘 10 * 20 = 200，还可以复制字符串
/ 除 10 / 20 = 0.5，注意结果为浮点数
// 取整除 返回除法的整数部分（商） 9 // 2 输出结果 4
% 取余数 返回除法的余数 9 % 2 = 1
** 幂 又称次方、乘方，2 ** 3 = 8 
  1. a, b = 1, 2
  2. print(a + b)
  3. print(a - b)
  4. print(a * b)
  5. print(a / b)
  7. # 使用加号可以拼接字符串
  8. print('abc' + '123')
  9. # 使用乘法可以复制字符串
  10. print('abc' * 10)
  11. # 在python3中，两个整数相除，结果必定为浮点数
  12. print(4 / 2)
  13. print(int(4 / 2))   # 使用int（）可以将数据转换成整数类型

2. 复合赋值

加法复合赋值

  1. a = 2
  2. a += 1        # 自增
  3. print(a)    # a = a + 1 = 2 + 1 = 3

其余运算符同理

3. 逻辑运算符

运算符 描述 示例
and 和，并且 True and True，结果为True
or 或者 True or False，结果为True
not 非 not True，结果为False 
  1. print(True and False)           # and  有一个假，结果为假
  2. print(True and True)            # 两边为真，结果为真
  4. print(True or False)            # or  有一个真，结果为真
  6. print(not True)                 # not  非真即假
  7. print(not False)                # 非假即真

4. 比较运算符

运算符 描述 示例
> 大于 3>2，返回True
< 小于 3<2，返回False
>= 大于或等于 2>=2，返回True
<= 小于或等于 1<=2，返回True
！= 不等于 3！=2，返回True
== 等等于 3==2，返回False

5. 运算符的优先级

永远记住先算括号内，再算括号外

第八章 字符串（Str）

1. 定义

由一对单引号/双引号/三单引号/三双引号包围的数据

2. 特点

  • 有序
  • 不可变

不可变图解

image.png

3. 字符串的索引和取值

image.png

字符串的索引从0开始

字符串取值：
根据索引来取值

  1. a[0]            # 取出字母H
  2. a[-1]           # 取出字母d

字符串切片语法：

  • [起始索引：结束索引：步长]
  • 注意：切片的时候是左闭右开型，即包含开始不包括结束
    1. print(a[0:2])  #  取出He
    2. print(a[0:4])  #  取出Hell
    3. print(a[-2:])  #  取出ld
    4. print(a[:])    #  从头取到尾
    5. print(a[::2])    #  从头取到尾,每隔2个取一个

4. 转义字符

转义字符：是指使用反斜杠\对一些特殊字符进行转义
常见的转义字符如下：

  1. \n        换行符
  2. \t        水平制表符（对齐）

让转义字符不转义的方法：

  • 在\后再加一根\：print('D:\\n\\t')
  • 在整个字符串前加r：print(r'D:\n\t')

    python路径中的正反斜线是等价的，举例：

  1. C:\\test    # 用两个斜线，避免被转义
  2. C:/test     # 用一个即可

5. 字符串的格式化

  • 把数据按照一定的格式打印或者填充

    5.1 百分号格式化

    先用下面的占位符占好位置，然后再将值传入

  • %s：字符串

  • %d：整数
  • %f：浮点数，通过%.nf指定精度，n是数字，保留几位就写几 ```python name = ‘小方’ age = 18 money = 100.1

print(‘他叫%s，他今年%d岁，他身上有%.1f元钱’ %(name, age, money))

  2. > 注意：如果需要填充多个值，值需要用括号括起来
  4. <a name="17b79d89"></a>
  5. ### 5.2 使用format函数
  6. 使用`format`进行格式化，统一用`{}`占位，不用考虑数据类型
  7. ```python
  8. print('他叫{}，他今年{}岁，他身上有{}元钱'.format(name, age, money))
  10. # 指定精度  {:.nf}
  11. print('他叫{}，他今年{}岁，他身上有{:.1f}元钱'.format(name, age, money))
  13. # 可以通过编号的方式，重复填入数据，注意编号从0开始
  14. print("他叫{0}，他今年{1}岁，我也是{1}岁，他身上有{2}元钱".format(name, age, money))

5.3 f{string}

  • 498新特性，直接在字符串前加f，大括号中直接指定变量，可以直接填充

  • 文档说明：https://www.python.org/dev/peps/pep-0498/

    1. # 方法三
    2. print(f"您输入的用户是：{username}，密码是：{password}")  
    3. # 如果需要保留小数，可以使用如下方法：
    4. num = 109.126
    5. print(f"zifuchuan:{num:0>.2f}")

    6. 字符串的常用方法

  • 替换字符串中的字符：str.replace(旧字符，新字符)

  • 分割字符串：str.split(分割标志)，返回列表
  • 查找指定字符：str.find(字符)，返回字符第一次出现的索引值，没有则返回-1 ```python a = ‘tashi’ a = a.replace(‘t’, ‘T’) # 替换字符串

b = ‘a, b, c, d’ result = b.split(‘,’) # 分割字符串 print(result)

print(a.find(‘G’)) # 查找指定字符，返回第一次出现的索引值，没有则返回-1

  1. <a name="75d1c505"></a>
  2. ##   7. 输入字符串
  4. - 从键盘输入字符使用`input(输入提示)`函数，并保存到指定的变量中。
  5. - `input`接收的所有数据都保存成字符串类型
  6. ```python
  7. print('欢迎来到它石科技管理系统~')
  8. username = input('请输入您的用户名：')
  9. password = int(input('请输入您的密码：'))   # 可以加类型转换
  10. print('您输入的用户名是：{}，密码是：{}'.format(username, password))

第九章 列表(List)

1. 定义

  • 列表是「Python」中的一种基础数据结构，由[]包围
  • 列表中每个数据就是一个元素，元素之间以 逗号 隔开

  • 列表中的元素可以是 任意 的数据类型

    2. 特点

  • 有序：有索引

  • 可变：可以修改自身

    3. 快速生成数字列表

    list(range(开始值，结束值，步长))

    注意：range同样包含开始但是不包含结束

  1. a = list(range(1, 101))            # 生成一个包含1-100之间的所有数字的列表
  2. b = list(range(2, 101, 2))   # 快速生成1-100之间的所有偶数的列表

4. 列表的嵌套取值

列表中的元素也可以是列表，叫做 列表嵌套
列表嵌套取值就是将取出的列表继续取值即可

  1. food = [['湖南', '槟榔'], ['福建', '沙县小吃', ['10块钱一份','好吃不贵']], ['湖北', '热干面']]
  2. print(food[0][1])                   # 取出槟榔
  3. print(food[1][2][0])                # 取出十块钱一份

5. 列表的常见方法

  • 增加
    • 追加元素到列表最后：list.append(值)
    • 在指定索引位置插入值：list.insert(索引，值)
  • 删除
    • 删除指定索引位置的值：list.pop(索引)，不填索引，则删除最后一个
    • 根据值删除元素：list.remove(值)，如果有多个值，则删除第一个
  • 修改
    • 先取值，再重新赋值：list[索引] = 新值
  • 反转：list.reverse()
  • 统计
    • 最大值：max(list)
    • 最小值：min(list)
    • 长度：len(list)

  • 排序

    • 从小到大：list.sort()
    • 从大到小：list.sort(reverse=True)

      第十章 元组（Tuple）

      1. 定义

  • 元组是「Python」中的一种基础数据结构，用()包围

  • 元组中的每个数据叫元素，元素之间用逗号隔开
  • 元素可以是任意的数据类型

  • 注意：当元组中有且只有一个元素时，必须要用逗号结尾，否则就不是元组

    2. 特点

  • 有序

  • 不可变

    3. 列表与元组互转

    如需修改元组，可将元组转成列表，进行修改，改完再转回即可
    1. a = (1, 2, 3)
    2. a = list(a)                 # 将元组转成列表
    3. a.append(4)             # 在列表中追加4
    4. a = tuple(a)             # 将列表转成元组
    5. print(a)

4. 元组常用方法

统计

  • 最大值：max(tuple)
  • 最小值：min(tuple)
  • 长度：len(tuple)

第十一章 字典（Dict）

1. 定义

  • 字典是「Python」中的一种基础数据结构，用{}包围
  • 字典中的元素以键值对的形式存在，

  • 键必须唯一，出现多个相同的键，只会记住最后一个

    2. 特点

  • 无序

  • 可变

    3. 字典的常用方法

  • 根据键修改值：dict[键] = 值

  • 根据键删除键值对：dict.pop(键)
  • 字典取值时，如果键值对不存在，则自动添加：dict[键] = 值
  • 获取所有键：dict.keys()
  • 获取所有值：dict.values()
  • 获取所有键值对：dict.items()

    第十二章 选择语句

    1. 格式

    1. if 条件：
    2.   条件满足时做的事情1
    3.   条件满足时做的事情2
    4.   ... ...
    5. else:
    6.   条件不满足时做的事情1
    7.   条件不满足时做的事情2
    8.   ... ...

练习：询问用户年龄，只有18岁及以上者才能进入酒吧

age = int(input('请输入您的年龄：'))    # 用户输入年龄
if age>=18:                                         # 判断用户的年龄是否大于等于18岁
    print('欢迎光临')
else:
    print('禁止未成年人进入！')

2. elif

判断多个条件

score = float(input('请输入您的成绩：'))
if 0<=score<60:
    print('您的成绩不合格')
elif score>=60 and score<70:
    print('您的成绩一般')
elif 70<=score<80:
    print('您的成绩是中等')
elif 80<=score<90:
    print('您的成绩良好')
elif 90<=score<=100:
    print('您的成绩优秀！')
else:
    print('您的输入有误，请重新输入！')

month = int(input('请输入月份：'))
if 3<=month<=5:
    print('春季')
elif 6<=month<=8:
    print('夏季')
elif 9<=month<=11:
    print('秋季')
elif month==12 or 1<=month<=2:
    print('冬季')
else:
    print('您的输入有误，请重新输入！')

# ----------------计算器-------------
# 编写一个小程序：对任意两数进行加减乘除运算
num1 = int(input("请输入第一个数字："))
num2 = int(input("请输入第二个数字："))
flag = input("请输入需要进行的运算（+、-、*、/）：")
if flag == '+':
    print(f'{num1}+{num2}={num1 + num2}')
elif flag == '-':
    print(f'{num1}-{num2}={num1 - num2}')
elif flag == '*':
    print(f'{num1}*{num2}={num1 * num2}')
elif flag == '/':
    print(f'{num1}/{num2}={num1 / num2}')
else:
    print("您的输入有误！")

# BMI计算器
# ============BMI计算器================
# BMI计算公式：体重(kg) / 身高(m)**2
print("欢迎使用它石牌BMI计算器~")
weight = float(input("请输入您的体重(kg)："))
height = float(input("请输入您的身高(m)："))
bmi = round(weight / (height ** 2), 1)
print(bmi)
if bmi <= 18.4:
    print("您的体型偏瘦,请多吃点~")
elif 18.5 <= bmi <= 23.9:
    print("您的体型正常，请继续保持~")
elif (bmi >= 24.0) and (bmi <= 27.9):
    print("您的体型过重，请多运动~")
elif bmi >= 28.0:
    print("您的体型肥胖，请绝食~")
else:
    print("您的输入有误~")

3. if 嵌套

在一个if中嵌入另外一个if

age = int(input('请输入您的年龄：'))        # 用户输入年龄
beer = True                                                   # 1表示带了酒水，0表示没有带
if age>=18:                                             # 判断用户的年龄是否大于等于18岁，只有年龄符合要求才有过安检的机会
    print('请过安检~')
    if beer==True:
        print('您不能进入，因为您带了酒水')
    else:
        print('欢迎光临')
else:
    print('禁止未成年人进入！')

4. if应用：猜拳游戏

import random            # 导入随机数包

player = int(input('请输入石头(0)剪刀(1)布(2)：'))    # 玩家出一个数字
computer = random.randint(0, 2)                            # 电脑随出一个0-2之间的随机整数
print('玩家出的是：{}，电脑出的是：{}'.format(player, computer))

# 所有玩家会赢的场景
if (player==0 and computer==1) or (player==1 and computer==2) or (player==2 and computer==0):
    print('恭喜你赢了，真棒~')
elif player==computer:            # 玩家与电脑平局的场景
    print('平局了哦，要不要再来一局~')
else:                                        # 剩下的就是玩家输的场景
    print('很遗憾，你输了，再接再厉~')

第十三章 循环语句

1. 程序的三大执行方式

03 | Python编程基础 - 图12

2. while循环

2.1 格式

while 条件：
    条件满足时重复做的事情

2.2 打印1-100之间的数字

num = 1
while num<=100:
    print(num)
    num += 1

2.3 打印矩形

num = 1
while num<=9:
    print('*'*9)
    num += 1

2.4 双层循环打印矩形

i = 1
while i<=9:                 # 外循环控制行数
    j = 1
    while j<=9:
        print('*', end='')  # 内循环控制每行个数，end=‘’让print不换行
        j += 1
    print('')               # 内循环执行完成后，主动换行
    i += 1

2.4 双层循环打印三角形

i = 1
while i<=9:                 # 外循环控制行数
    j = 1
    while j<=i:
        print('*', end='')  # 内循环控制每行个数，end=‘’让print不换行
        j += 1
    print('')               # 内循环执行完成后，主动换行
    i += 1

2.5 双层循环打印九九乘法表

i = 1
while i<=9:               
    j = 1
    while j<=i:
        print('{}*{}={}'.format(j,i,j*i), end='\t')  
        j += 1
    print('')               
    i += 1

2.6 面试题：数7游戏

# --------------------数7游戏-----------
# 打印1-20之间不是7的倍数以及数字中不包含7的数字
i = 1
while i<=20:
    # if i%7!=0 and str(i).find('7')==-1:
    if i%7!=0 and i%10!=7:
        print(i)
    i += 1

2.7 while习题

# 模拟一个登录系统，当用户名为admin, 密码为123时即登录成功，否则登录失败
# 只有三次登录机会
print("欢迎使用管理系统~")
i = 1
while i <= 3:
    username = input("请输入您的用户名：")
    password = input("请输入您的密码：")
    if username == "admin" and password == "123":
        print("登录成功")
        break   # 如果登录成功，则跳出剩下所有循环
    else:
        print("登录失败")
    i += 1

3. for循环

3.1 格式

for   临时变量   in  序列:
    循环体

3.2 作用

  • 一般用来 遍历 序列
  • 循环次数与序列长度对应 ```python for i in ‘abc’: # 遍历字符串 print(i)

for i in [1,2,3]: # 编列列表 print(i)

student = {‘name’:’zs’, ‘age’:18, ‘sex’:’boy’} print(student.items()) for i in student.keys(): print(i) for i in student.values(): print(i) for i,j in student.items(): # 遍历字典中键值对 print(‘{}={}’.format(i,j))

<a name="7c47bb21"></a>
### 3.3 打印1-100之间的数字
```python
for i in range(1, 101):      # 打印1-100之间的数字
    print(i)

3.4 打印矩形

for i in range(1, 10):      # 打印9*9的矩形
    print('*'*9)

3.5 打印三角形

for i in range(1, 10):
    for j in range(1, i+1):
        print('*', end='')
    print('')

3.6 打印九九乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f'{j}*{i}={j * i}', end='\t')
    print()

3.7 for与if嵌套使用

names = ['zs', 'ls', 'ww']
for i in names:
    if i=='zs':
        print('恭喜你中奖了~')
    else:
        print('不好意思，没有中奖')

3.8 习题

# ----------------练习题1： 获取任意字符串的长度（不能使用len（））------------------
a = input('xxx')
num = 0
for i in a:
    num += 1
print(num)

# ----------------练习题2: 求1-100之间所有能被3整除且不能被4整除的数------------------
nums = []
for i in range(1,101):
    if i%3==0 and i%4!=0:
        nums.append(i)
print(nums)
# ---------------练习题3：统计任意字符串中的数字与字母个数，分别打印--------------------
a = input('请输入需要统计的字符串：')
num = 0
letter = 0
for i in a:
    if i in '1234567890':
        num += 1
    elif i in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
        letter += 1
print('该字符串中数字的个数是{}，字母的个数是：{}'.format(num, letter))

# isdigit  数字     isalpha  字母

# ---------------练习题4：求1-100之间所有偶数和--------------------------
a = 0
for i in range(2, 101, 2):
    a += i
print(a)

for i in range(1, 101):
    if i%2==0:
        a += i
# -----------------练习题5：兔子数列，假设有1对兔子，2个月成年，成年后可以生一对兔子，假设所有兔子
# -------------------------不会死的情况下，第12个月会有多少对兔子？-----------------------
# ----------------斐波那契数列：从1开始，后面的数是前面两数之和-----------------
# 1 1 2 3 5
a, b = 0, 1
nums = []
for i in range(1, 13):
    nums.append(b)
    a, b = b, a+b
print(nums)

4. 冒泡排序

# ---------------------冒泡排序--------------------
# 从小往大
nums = [10, 3, 4, 1]
for i in range(len(nums)-1):                        # 控制比较次数
    for j in range(len(nums)-1-i):                  # 控制每次用来比较数字的索引值
        if nums[j]>nums[j+1]:                       # 如果第一个数字比第二个数字大
            nums[j],nums[j+1] = nums[j+1], nums[j]  # 则交换位置
print(nums)

5. 跳出循环

  • break：跳出剩下的整个循环

  • continue：跳出本次循环

    第十四章 函数

    1. 函数的定义

  • 函数就是将具有相同功能的代码块 封装 成一个小模块

  • 封装好以后不仅可以 无限次 使用并且可以在 不同 地方使用
  • 通过函数名（)的方式可以调用函数

    注意：函数在定义好以后不会自动运行

2. 格式

def    函数名（）：
    代码块

3. 文档注释

  • 函数的文档注释用一对三单引号/双引号包围，用来解释说明函数的作用

  • 在代码中使用help(函数名)可以查看到函数的文档注释

    4. 函数的参数

  • 形式参数：函数定义时的参数

  • 实际参数：调用函数时传入的参数 ```python def addtion(a, b): # a，b是形式参数 c = a + b print(c)

addtion(2, 2) # 2,2是实际参数

<a name="71d6def8"></a>
##   5. 函数参数的传递方式

- **位置传递**：形参与实参按照位置关系一一对应
- **关键字传递**：在调用函数时，通过实参指定形参的值，不受位置关系影响（可以乱序）
- **参数的默认值**：函数的形参可以有默认值，如果形参有默认值并且调用时没有传入实参，则使用默认值，如果传入了实参，则使用传入值，没有默认值的形参必须要放到有默认值的形参前面
```python
# -------------------关键字传递----------------------
def addtion(a, b):      # a，b是形式参数
    c = a - b
    print(c)
addtion(b=2, a=3)         # 指定形参的值，不受位置关系影响

# -------------------参数的默认值--------------------
def addtion(b, a=3):      # a，b是形式参数
    c = a - b
    print(c)
addtion(2)                # 如果形参有默认值，则调用时可以不传入实参，不传则使用默认值

6. 函数的返回值

  • 函数执行后一般情况下都会产生执行结果，使用return将执行结果返回给调用者，这就是返回值
  • 如果函数中没有定义return，则函数的返回值为None

  • 函数一旦执行到return，就不会继续往下执行

    def addtion(a,b):
  return a+b                    # 使用return将执行结果返回给调用者

    7. 局部变量与全局变量

  • 局部变量：定义在函数内部的变量，只在函数内部生效

  • 全局变量：定义在函数外部的变量，整个代码文件都生效
  • 使用global可以将局部变量声明成全局变量
    num = 10            # 全局变量
def addtion():
  global a        # 使用global可以将局部变量声明成全局变量
  a = 10          # 局部变量
  print(num)

第十五章 异常处理

1. 捕获异常

当代码中出现异常时，程序会抛出异常并且停止运行，如果希望代码在出现异常后，继续往下执行，则需要捕获异常
捕获异常的格式：

try：
    可能会出现异常的代码
except Exception as e：
    出现异常后执行的代码
else：
    没有异常时执行的代码
finally：
    不管有没有异常都会执行的代码

注意：else与finally为非必写

print('程序开始执行...')
try:
    print(a)   # a没有定义，会报错
except Exception as e:
    print('程序出现了异常，异常是：{}'.format(e))
# else:
#     print('恭喜你，没有任何异常！')
# finally:
#     print('我一定会执行')
print('程序执行结束...')

2. 抛出异常

当希望代码在指定情况下出现异常，则需要抛出异常
抛出异常的格式为：raise Exception(错误提示)

# 希望用户输入一个大于100的整数
# 如果用户输入有误，则抛出异常
print("程序开始了")
num = int(input("请输入一个大于100的整数："))

if num > 100:
    print("输入成功")
else:
    try:
        raise Exception("输入有误！")
    except Exception as e:
        print("程序出现了异常，异常信息是：{}".format(e))

print("程序结束了")

第十六章 文件操作

1. 打开文件

打开文件使用open（file，mode）函数，该函数参数定义如下：

  • file：文件名，可以是包含路径的文件名

  • mode：文件打开模式

    • r：只读模式，文件不存在则报错
    • w：写入模式，文件不存在可以自动创建，会覆盖原内容
    • a：追加模式，文件不存在可以自动创建

      2. 关闭文件

      使用close（）函数可以将文件关闭，所有文件操作后都必须关闭
      使用closed可以判断文件是否关闭，已关闭返回True，反之返回False

      3. 写入

      使用write(str)可以将数据写入文件，数据必须是str

      4. 读取

  • 读取所有内容：read（）

  • 读取前n个字符：read(n)，多次使用会从上次读取位置继续往后读取
  • 读取一行：readline()，多次使用会从上次读取位置继续往后读取
  • 按行读取所有内容：readlines()，返回列表

    5. 中文处理

    在文件中写入 中文 时可能会出现 乱码 现象，这时指定文件的编码格式为utf-8，即可解决该问题
    #  中文乱码时，加上encoding指定编码方式，为utf-8
file = open('tashi.txt', 'w', encoding='utf-8')
file.write('中国很强！')
file.close()

    6. 文件的自动打开与关闭

    使用with open结构打开文件，在文件操作结束后可以自动关闭文件
    with open('tashi.txt', 'r', encoding='utf-8') as f:
  result = f.read()
  print(result)
print(f.closed)                    # 使用closed验证文件是否已经关闭

    7. 应用：备份文件

    ```python old_file = input(‘请输入需要备份的文件：’)

suo_yin = old_file.find(‘.’) hou_zhui = old_file[suo_yin:] # 取出文件后缀 qian_zhui = old_file[:suo_yin] # 取出.前面的部分 new_file_name = qian_zhui + ‘-副本’ + hou_zhui # 拼接新文件名 file = open(old_file, ‘r’, encoding=’utf-8’) # 读取原文件内容 result = file.read() file2 = open(new_file_name, ‘w’, encoding=’utf-8’) # 将读取内容写入新文件 file2.write(result)

file.close() # 关闭文件 file2.close()


<a name="f87a1b4c"></a>
#   第十七章  模块
<a name="5d7b406e"></a>
##   1. 导入模块的方法

- `import 模块名`
- `from 模块名 import 函数`
<a name="2f42eb74"></a>
##   2. 安装模块
<a name="759136c8"></a>
### 2.1 自动安装

- 在命令行中输入：`pip install 模块名`，默认安装最新版本
- 安装指定版本：`pip install 模块名==2.1`
- 验证是否安装成功：`pip list`，（查看所有已安装模块及版本号）
<a name="98599a38"></a>
### 2.2 手动安装

- 进入[https://pypi.org](https://pypi.org)，搜索下载需要安装的包
- 将下载好的包解压
- 进入解压目录，在顶部地址栏中输入`cmd`（在当前位置打开命令行）
- 在打开的命令行中输入：`python setup.py install`（手动执行本地安装）
<a name="c0e9f855"></a>
##   3. 常用模块
**time（时间）**
```python
import time

# 获取当前时间
print(time.ctime())
# 获取当前时间，并且按照指定格式保存  2019-10-29 14:52:01
print(time.strftime('%Y/%m/%d %H:%M:%S'))
# 休眠
time.sleep(2)
print(time.strftime('%Y/%m/%d %H:%M:%S'))

OS（系统）

import os

# 获取当前文件所在路径
print(os.getcwd())
# 获取当前文件所在目录的上级目录
print(os.path.dirname(os.path.dirname(__file__)))
os.mkdir('linux') # 新建目录
os.rmdir('linux')   # 删除目录
os.remove('tashi-副本.txt')   # 删除文件

删除非空目录：

import shutil
shutil.rmtree('c:\\test')

json

# --------------------读取json--------------------------

import json

result = json.loads('{"name":"zs", "age":18}')  # 将字符串类型json数据转为字典
print(type(result))    

# --------------------生成json--------------------------

dict_data = {"name":"zs", "age":18}         # 将字典转换成字符串类型的json数据
json_data = json.dumps(dict_data)
print(type(json_data))

注意：字典中包含中文，转为json时中文乱码， 传入ensure_ascii=False参数即可解决

第十八章 面向对象

1. 面向对象与面向过程

  • 面向过程：根据业务流程从上往下写代码，所有步骤都参与（吃烤鸭：买鸭蛋—>养鸭子… …）

  • 面向对象：将数据与函数绑定在一起，定义成类，通过类可以生成无数个对象，提高开发效率（吃烤鸭：直接买）

    2. 类和对象

  • 类是泛指一类事物（狗，猫，人… …）

  • 对象是单指某一个具体的事物（xx家的狗）

    3. 类的组成部分

  • 类名（dog）

  • 属性（狗有2只眼睛，4条腿… … ）
  • 方法（狗能吃，跑，叫… …）

    4. 定义类

    定义一个 狗类
    class Dog():    # 类名用大驼峰
  # 属性
  # 方法
  def eat(self):
      print('狗正在吃东西')
  def chai_jia(self):
  print('狗正在拆家')
    根据类创建对象 ```python wangcai = Dog() # 类的实例化，就是创建对象 wangcai.eat() # 对象调用类中的方法 wangcai.chai_jia()

dahuang = Dog() dahuang.eat()

<a name="9044f9f5"></a>
##   5. 类的初始化
在类中使用`__init__`方法进行自动化，并将类属性定义在该方法中<br />类属性与`self`绑定，这样就可以在其他方法中使用该属性
```python
class Dog():    # 类名用大驼峰
    # 属性
    def __init__(self):     # 在初始化方法中定义属性值，初始化一定会自动运行
        self.color = '黄色'   # 通过self绑定属性，这样就可以在其他方法中使用该属性
        self.food = '骨头'
        print('初始化开始~')

6. 继承

如果一个类是一个大类中的一小类，那么这个类可以继承这个大类
被继承的类叫 父类，继承的类的叫 子类
子类继承父类以后有如下特点：

  • 子类可以使用父类中的 所有 方法
  • 子类可以新增父类中 没有 的方法

  • 子类可以 修改 父类中的方法

    class XiaoTianQuan(Dog):        # 哮天犬继承狗类
  def eat(self):
      print('哮天犬正在吃仙丹')   # 在子类中定义一个与父类同名的方法，达到修改方法的效果

  def fly(self):                  # 哮天犬新增自己独有的方法
      print('哮天犬正在飞~')
XTQ = XiaoTianQuan()            # 实例化，生成一只哮天犬
XTQ.eat()                       # 使用父类中的方法
XTQ.chai_jia()
XTQ.fly()

    7. 最终

    ```python

    定义一个狗类

class Dog(): # 类名用大驼峰

# 属性
def __init__(self, color, food):     # 在初始化方法中定义属性值，初始化一定会自动运行
    self.color = color   # 通过self绑定属性，这样就可以在其他方法中使用该属性
    self.food = food
    # print('初始化开始~')
# 方法
def eat(self):
    print('{}的狗正在吃{}'.format(self.color, self.food))

def chai_jia(self):
    print('{}的狗正在拆家'.format(self.color))

wangcai = Dog(‘金色’, ‘剩饭’) # 类的实例化，就是创建对象 wangcai.eat() # 对象调用类中的方法 wangcai.chai_jia()

hashiqi = Dog(‘黑白相间’, ‘狗粮’) hashiqi.eat()

继承

class XiaoTianQuan(Dog): # 哮天犬继承狗类 def eat(self): print(‘哮天犬正在吃仙丹’) # 在子类中定义一个与父类同名的方法，达到修改方法的效果

def fly(self):                  # 哮天犬新增自己独有的方法
    print('哮天犬正在飞~')

XTQ = XiaoTianQuan(‘红色’, ‘仙丹’) # 实例化，生成一只哮天犬 XTQ.eat() # 使用父类中的方法

XTQ.chai_jia()

XTQ.fly()


<a name="34426d78"></a>
#   第十九章  习题
<a name="2efd0f0e"></a>
## 1. 数7游戏
```python
# -----------------------数7游戏-------------------------
# 7的倍数以及包含7的数字都不能说，只能拍手
i = 1
nums = []
while i<=100:
    if i%7!=0 and str(i).find('7')==-1:
        nums.append(i)
    i += 1
print(nums)

2. BMI计算器

# --------------------BMI计算器----------------------
print('欢迎来到它石BMI计算器~')
weight = float(input('请输入您的体重（kg）：'))
hight = float(input('请输入您的身高（m）：'))
bmi = float(format(weight/hight**2, '.1f'))
print(type(bmi))
print('请稍后，正在计算中~')
print('您的BMI指数为：{}'.format(bmi))

if bmi<=18.4:
    print('您的体型偏瘦，多吃点~')
elif 18.5<=bmi<=23.9:
    print('您的体型正常，继续保持~')
elif 24.0<=bmi<=27.9:
    print('您的体型过重，少吃点~')
elif bmi>=28.0:
    print('您的体型肥胖，请辟谷~')
else:
    print('您的输入有误，请重新输入~')

3. 输入数字并排序

# -----------用户输入三个数字，将这三个数字按照从小到大顺序排列并输出------------------
nums = []
for i in range(3):
    num = int(input('请输入一个整数：'))
    nums.append(num)
nums.sort()
print(nums)

4. 批量生成SQL

# -----------------练习题7：批量生成SQL--------------------
# inert into student value(tashi00001);, 从1-10000，写入tashi.txt中
with open('tashi.txt', 'w') as f:
    for i in range(1, 10001):
        f.write('insert into student value(tashi{:0>5d});\n'.format(i))

5. 字典中的键值颠倒

现有sport = {'cn':'pingpang', 'us':'basketball', 'africa':'football'}，请将该字典中的键值颠倒并产生新的字典

sport = {'cn':'pingpang', 'us':'basketball', 'africa':'football'}
# sport = {y:x for x,y in sport.items()}
# print(sport)
new_sport = {}
for k,v in sport.items():
    new_sport[v] = k
print(new_sport)

6.闰年判断

输入任意年份，判断该年份是否为闰年

year = int(input('请输入需要查询的年份：'))
if (year%4==0 and year%100!=0) or year%400==0:
    print('{}年是闰年'.format(year))
else:
    print('{}年不是闰年'.format(year))

7. 输入多个数字，判断大小

用户输入任意5个数字，请将这个5个数字中最大数字找出来并打印

nums = []
for i in range(1,6):
    num = int(input("请输入第{}个数字：".format(i)))
    nums.append(num)
print('您输入的数字中，最大数字为{}'.format(max(nums)))

8. 简单计算器

编写一个小程序：实现简单的加减乘除功能

print('请选择您需要的运算：')
print('1.加法运算')
print('2.减法运算')
print('3.乘法运算')
print('4.除法运算')
choice= int(input('请输入您的选择：1(加法)/2(减法)/3(乘法)/4(除法):'))
num1 = int(input('请输入第一个数字：'))
num2 = int(input('请输入第二个数字：'))

if choice==1:
    print('{} + {} = {}'.format(num1, num2, jia(num1, num2)))
elif choice==2:
    print('{} - {} = {}'.format(num1, num2, jian(num1, num2)))
elif choice==3:
    print('{} * {} = {}'.format(num1, num2, cheng(num1, num2)))
elif choice==4:
    print('{} / {} = {}'.format(num1, num2, chu(num1, num2)))
else:
    print('您的输入有误！')

9. 统计字符出现的个数

统计任意字符串中每个字符出现的次数

def count(str):
    result = {}
    for i in str:
        if i in result:
            result[i]+=1
        else:
            result[i]=1
    return result

print(count('abc'))

10. 求100以内的所有质数

# python求100以内的质数
# 质数定义是大于1的自然数中，除了1和它本身外不再有其他因数
nums = []
for i in range(2, 101):
    for j in range(2, i):
        if i%j==0: # 如果条件满足，直接跳出for，不执行else
            break
    else:         # 如果条件不满足，则添加这个数到列表中
        nums.append(i)
print(nums)

# [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

11. 判断回文字符串

回文字符串就是不管从左往右还是从右往左看，值都是一样的

# a = 'abcba'
a = input("请输入需要判断的字符串：")
b = reversed(list(a))  # 将字符串转成列表后再反转一下

if list(a) == list(b):  # 如果输入的字符串转成列表后和反转过后的列表的值一样，那么就是回文字符串
    print('是回文')
else:
    print('不是回文')

12. 统计列表中字符串出现的次数

现有 a = [“apple”, “banana”, “apple”]，统计其中每个单词出现的次数

a = ["apple", "banana", "apple", "apple", "banana"]
res = {}
for i in a:
    res[i] = res.get(i, 0) + 1
print(res)

# {'apple': 3, 'banana': 2}

13. 合并两个列表为字典

现有 a = [“a”, “b”, “c”]， b = [1, 2, 3]，将a，b合并为字典。a中的元素作为字典中的键，b中的元素作为字典中的值。

a = ["a", "b", "c"]
b = [1, 2, 3]

res = dict(zip(a, b))
print(res)

14. 列表推导式

现有 a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，使用列表推导式求出所有奇数并构造新列表

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
res = [i for i in a if i%2!=0]
print(res)

15. 列表元素长度排序

现有 a = [“ab”, “a”, “a12”, “xmkj12”]，将该数据按照每个字符串长度排序

# 方法一
a = ["ab", "a", "a12", "xmkj12"]
a.sort(key=lambda x:len(x))
print(a)

# ['a', 'ab', 'a12', 'xmkj12']

# 方法二
a = ["ab", "a", "a12", "xmkj12"]
for i in range(len(a)):
    for j in range(len(a) - 1):
        if len(a[j])>len(a[j+1]):
            a[j], a[j+1] = a[j+1], a[j]
print(a)