Python基础知识

Python基础

第一章 Python简介

1.Python起源

• Python是吉多*范罗苏姆在1989年圣诞节，为了打发无聊而编写的一个解释程序
• python的意思：蟒蛇
• 解释型编程语言，无需编译
• 一般情况下，同样的功能，python的代码量是java的1/5
• 名言：life is short，you need python（人生苦短，我用python）
• 现有版本
  • python2.X（过去的版本），发布于2001年
  • python3.X（现在和未来主流版本，3.0发布于2008年）

2. Python的应用

• 云计算：云计算最火语言（云服务器）

• web开发：YouTube，豆瓣，知乎

• 人工智能：语音助手，AI音箱

• 自动化测试：我们使用的

3. Python的优点

• 易学
• 免费，开源
• 可移植性强（Windows，macOS，Linux）
• 丰富的库（拓展功能）

第二章 安装Python

1. 下载Python安装包

• 网址：www.python.org
• 注意：下载前要先确定系统位数

2. 安装

• 注意勾选添加python至系统环境变量（path）

• 修改安装路径（安装至C盘根目录，方便查找）

安装Python截图

3.第一个python程序

• win+r，输入cmd，打开命令行窗口
• 在命令行窗口中输入python，进入python交互模式
• 在交互模式中输入如下代码：

# 打印“你好，世界！”
print('Hello World!')

Hello World!

第三章 输出与输入

1.输出

使用print函数在控制台输出指定内容

1.1 输出字符串和数字

# 输出字符串
print('Helloworld')

# 输出数字
print(123)

1.2 输出多个内容

需要同时输出多个内容时，使用逗号隔开

print('Helloworld',123)

1.3 输出不换行

print输出时默认是换行的，如果不想换行需要传入end参数

print('Helloworld',end='')

2.输入

python3中使用input函数从键盘获取数据，返回string类型

注意：在python3中，input将所有输入的数据都保存为字符串类型

username = input('请输入您的用户名：')

使用input输入数据，如果需要保持原类型，比如输入数字保存为原数字类型，需要进行转型操作

# 在input前加int（）将输入数据转成整数类型
username = int(input('请输入您的用户名：'))

第四章 安装Pycharm(编辑器)

1.下载Pycharm

• Pycharm官网地址：http://www.jetbrains.com/pycharm/

2.安装Pycharm

3.配置本地解释器

第五章 注释

1. 注释的作用

• 注释一般是用来说明代码的作用
• 纯给人看的，机器不会执行注释里的内容

2. 单行注释

• 单行注释，用#号表示
• 单行注释可以单独写一行，也可以写在需要注释的代码的右侧

# 这是一个单行注释
# 单行注释用一个#表示
# 可以在单独行写，也可以在某行代码后面写
print("hello word")

hello word

3. 多行注释（块注释）

• 多行注释，用一对三单引号或者双引号表示
• 多行注释通常用来为python文件、模块、类或者函数添加版权，功能等信息
• 多行注释可以用单行注释来实现

'''
这是多行注释
多行注释用三个单引号表示
多行注释中间会保持原格式
多行注释也叫文档注释(一般放在函数里)
'''

'\n这是多行注释\n多行注释用三个单引号表示\n多行注释中间会保持原格式\n多行注释也叫文档注释(一般放在函数里)\n'

第六章 基础数据类型

• 查看数据类型用type（）函数，不能传两个数据类型

1. 整数（int）

游戏中使用数字记录分数，销售网站使用数字记录数量等

• 100，0，-100

a = 100				# 正整数
b = 0				# 0也是整数
c = -100			# 负整数
print(type(a))
print(type(b))
print(type(c))

<class 'int'>
<class 'int'>
<class 'int'>

2. 浮点数（float）

• 1.23，-1.0，0.0
• 注意：python中的除法结果会将整数转换成浮点数

a = 1.23			# 正浮点数
b = -1.0			# 负浮点数
c = 0.0				# 0.0也是浮点数
print(type(a))
print(type(b))
print(type(c))

<class 'float'>
<class 'float'>
<class 'float'>

注意：使用浮点数计算时，可能会出现小数位不确定的情况，暂时忽略即可，所有语言都有这个问题

print(0.1 + 0.2)

#0.30000000000000004

3. 字符串（str）

• ‘abc’
• ‘’（空字符也是字符串类型）

a = 'abc'
b = ''              # 空字符串
c = '我爱中国！'
print(type(a))
print(type(b))
print(type(c))
print(a)
print(b)
print(c)

<class 'str'>
<class 'str'>
<class 'str'>
abc

我爱中国！

4. 布尔值（bool）

• True（真）
• False（假）

注意：布尔值可以转换为数值，True表示1，False表示0，但是不建议对布尔值进行计算

a = 1
b = 2
print(a<b)
print(a>b)

True
False

# 布尔值的计算
# True为1，Flase为0
a = 1
b = 2
c = a < b    # c为True
d = a > b    # d为False

e = d - c    # e = 0 - -1
print(e)

5. 空值（None）

• 表示什么也没有
• 注意：不同于0和空字符串
• 用来占位置

a = None
print(type(a))

<class 'NoneType'>

第七章 变量

1. 变量的定义

• 变量是一个容器，里面可以存任意类型的数据

teacher = '刘老师'  # 定义了一个变量，变量名叫teacher，他里面储存了一个字符串刘老师

print(teacher + '简直帅毙了！')

如果又看见一次teacher=xxx，那么就不是定义变量了

而是变量的重新赋值

• 变量实质是储存在内存中的值，创建变量会在内存中开辟一个空间
• 变量是可以重复使用的一个量

2. 变量的命名规范

• 只能由数字、大小写字母、下划线组成
• 不能以数字开头
  • 4man，5for 是不可以的
  • man4，for5 是可以的
• 区分大小写
  • forMan 与 forman不是一个变量名称
• 不能使用系统关键字
  • class，from等 不可以
• 不推荐使用下划线开头，下划线开头具有特殊含义
• 推荐
  • 使用具有固定含义的英文单词缩写：srv=server，number=num
  • 驼峰命名法
    • 大驼峰：每个单词第一个字母大写（FirstName，LastName） 用在类名
    • 小驼峰：第一个字母小写，第二个单词开始每个单词首字母大小（firstName，lastName）变量或者函数名
    • 下划线：多个单词用下划线连接，单词全部小写（first_name, last_name）

什么是系统关键字？

• python一些具有特殊功能的标示符，这就是所谓的关键字
  • class, def, for...

怎么查看系统自带关键字

• 导入keyword包
• 使用keyword.list查看

# 查看关键字的方法
import keyword     # 导入关键字模块
print(keyword.kwlist)  # 打印出全部系统关键字

['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']

3. 变量的赋值

普通赋值

• 把赋值运算符右边的值给左边的变量

a = 100            #把整数100赋值给a
print(a)

100

序列解包赋值

• 左边的变量与右边的值一一对应

a,b,c = 1,2,3
print(a, b, c)

1 2 3

链式赋值

• 一个值给多个变量

# 三个变量都放入同一个值
a = b = c = 1
print(a)
print(b)
print(c)

1
1
1

第八章 运算符

1. 算术运算符

加、减、乘、除

注意：

• 除法会将整数转为浮点数

• 除数不能为0，否则会报错

# 两个对象相加
a, b = 1, 2
print(a + b)

# 两个对象相减
a, b = 10, 5
print(a - b)
# 使用负号得到负数
c = -5
print(c)

# 两个数相乘，乘号用*表示
a, b = 1, 2
c = a * b
print(c)

# 两个数相除，除号使用/表示
# 注意：除法会将整数转为浮点数
# 注意：除数不能为0，否则会报错
a, b = 10, 5
print(a/b)

取整除

• 两个数相除，返回商的整数部分

a, b = 10, 5
print(a//b)

2

取余

• 两个数相除，返回余数

注意：取余时，如果除数是负数，那么结果也是一个负数

a, b = 3, 2
print(a%b)

1

2. 赋值运算符

• “=”表示赋值运算符
• 把右边的结果给左边的变量

a = 2
c = a + 2
print(a)
print(c)

2
4

加法赋值运算符

• c += a 等效于 c = c + a

a = 1
a += 1
print(a)

4. 逻辑运算符

• and：与，并且
  • 两个都为真，结果为真
  • 有一个为假，结果为假
• or：或
  • 有一个为真，结果为真
• not：非

a = True
b = False
c = True

d = a and b    # 有一个假，结果为假
print(d)

d = a and c    # 两个都为真，结果为真
print(d)

d = a or b    # 有一个为真，结果为真
print(d)    

d = not a     # 非真即假
print(d)

d = not b     # 非假即真
print(d)

False
True
True
False
True

6.比较运算符

如果比较结果为真，则返回True；

如果比较结果为假，则返回False。

• 大于：>
• 小于：<
• 大于等于：>=
• 小于等于：<=
• 不等于：!=
• 等等于：==（两边值相等返回true，不相等返回false）

7. 运算符的优先级

• 永远记住，括号具有最高优先级

a, b, c = 1, 2, 3

d = a + (c - b)      # 把想要优先运算的部分用括号括起来
print(d)

2

第九章 字符串

1. 字符串的定义

• 字符串是python中的一种基础数据结构
• 通常是由引号包围的序列
  • 单引号
  • 双引号
  • 三单引号
  • 三双引号
• 特点

  • 有序

  • 不可变

love = 'i love you'    # 单引号
print(love)

love = "i love you"    #双引号
print(love)

# 三单引号
love = '''             
i
love
you
'''
print(love)

# 三双引号
love = """
i
love
you
"""
print(love)

i love you
i love you
             
i
love
you

2. 格式化

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

2.1 百分号格式化

利用百分号（%）

• %s：字符串
• %d：整数
• %f：浮点数

# 使用百分号格式化输出
name = '小明'
age = 18
crash = 100.0

print('%s今年%d了，他有%f元现金。' %(name, age, crash))

# %f输出浮点数的时候可以指定精度，%.2f：保留两位
print('%s今年%d了，他有%.2f元现金。' %(name, age, crash))

小明今年18了，他有100.000000元现金。
小明今年18了，他有100.00元现金。

2.2 format格式化

# 使用format函数格式化输出
# 用大括号占位
s = "i love {}".format("china")
print(s)

# 用大括号加编号占位，从0开始编号
y = "i love {0}, i am {1} years old, i love {0} very much!".format("china", 20)
print(y)

i love china
i love china, i am 20 years old, i love china very much!

3. 转义字符

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

常见的转义字符如下：

\n		换行符
\t		水平制表符

注意：在字符串前加上字母r（或R），那么该字符串就会原样输出，其中的转义字符将不会进行转义

# 打印出 i'm ‘OK’！
print("I\'m \'ok\'!" )

# 打印文件路径：c:\user
print('c\\:user')

print(r"\t表示制表符")
print('制表符前\t制表符后')

print(r'\n表示换行')
print("第一行\n第二行")

print(r"这句话里的东西都不转义\\")

print("打印结束加end", end='hi')#end为空字符串时，可以起到不换行的作用

I'm 'ok'!
c\:user
\t表示制表符
制表符前	制表符后
\n表示换行
第一行
第二行
这句话里的东西都不转义\\
打印结束加endhi

4. 字符串的索引和取值

索引

• <索引>就是编号
• 索引从0开始，不是从1开始
• 字符串实际上是字符的数组，所以也支持索引

name = 'HelloWorld'
print(name[0])		# H
print(name[1])		# e
print(name[2])		# l

取值

• 取值是指对操作对象截取其中的一部分操作

• 取值的语法：[起始：结束：步长]

  • 注意：截取的区间为左闭右开，即从起始开始到结束前一位，不包括结束

• 使用方法：

  • [:]：从开始提取到结尾

  • [start:]：从起始下标提取到结尾

  • [:end]：从开头提取到结束下标，不包括结束下标

  • [start:end]：从起始下标截取到结束下标，不包括结束下标

    name = 'zhangsan'           # 从开头提取到结尾
    print('从开头截取到结尾：{}'.format(name[:]))
    
    name = 'zhangsan'           # 从起始下标提取到结尾
    print('从起始下标1截取到结尾：{}'.format(name[1:]))
    
    name = 'zhangsan'           # 从开头提取到结束下标5
    print('从开头提取到结束下标5：{}'.format(name[:5]))
    
    name = 'zhangsan'           # 从起始下标截取到结束下标3
    print('从起始下标1截取到结束下标3：{}'.format(name[1:3]))
    
    name = 'zhangsan'           # 从开头截取到结尾，步长为2
    print('从开头截取到结尾，步长为2：{}'.format(name[::2]))
    
    

    从开头截取到结尾：zhangsan
    从起始下标1截取到结尾：hangsan
    从开头提取到结束下标5：zhang
    从起始下标1截取到结束下标3：ha
    从开头截取到结尾，步长为2：za
    
    

5. 字符串的常见方法

• 分割字符串：str.split()
• 将字符串中的某字符替换成其他字符
  • str.replace(原字符，新字符，替换次数)
  • 注意：可以通过次数来指定替换几次，适用于一个字符出现多次的情况

# 分割字符串
name = "a,b,c,d"
print(name.split(","))   # 遇到逗号就分割，返回列表

# 将字符串转为大写
name = "abcd"
print(name.upper())

# 将字符串转为小写
name = "ABCD"
print(name.lower())

# 替换字符
name = "abcd"
print(name.replace("a", "A"))  # 参数：被替换字符，替换后字符

['a', 'b', 'c', 'd']
ABCD
abcd
Abcd

6. 查找字符串

使用str.find()可以查找字符串中字符串出现的位置

返回字符串的第一次出现的索引，找不到则返回-1

格式：str.find(目标字符，开始位置，结束位置)

str = 'abbcdefg'
print(str.find('b'))  # 查找a字符出现的位置，返回索引值
print(str.find('b',2))  # 从索引2的位置开始查找a字符，注意返回的索引值还是从0开始的

1
2

第十章 列表

1.列表的定义

• 列表是Python中的一种基础数据结构之一
• 列表用[]包围，元素用逗号隔开
• 元素可是任意数据类型
• 特点
  • 有序
  • 可变

虽然列表元素可以是任意数据类型，但是通常情况只放入一种类型的数据，这样可以提高程序的可读性

# 定义一个列表
a = [1, 2, 3]
print(a)

[1, 2, 3]

list搭配range函数可以快速生成列表

# 快速生成一个偶数列表
l = list(range(2,11,2))
print(l)

2. 列表的循环嵌套取值

• 将取出的列表作为新的列表继续取值即可

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

# 取出数字2
print(a[2][1])

2

3. 列表的常见方法

增加

# 添加值
a = [1, 2 ,3]
a.append(4)
print(a)

[1, 2, 3, 4]

# 指定位置插入值
# 注意：insert插入值得效率没有append高
a = [1, 2 ,3]
a.insert(0, 0)   # 索引，值
print(a)

[0, 1, 2, 3]

删除

# 删除指定索引位置的值，不填索引删除最后一个
a = [1, 2 ,3]
a.pop()
print(a)

a = [1, 2 ,3]
a.pop(0)
print(a)

[1, 2]
[2, 3]

# 删除指定值
a = [1, 2, 3]
a.remove(3)
print(a)

[1, 2]

修改

# 修改指定索引位置的值
a = [1, 2, 3, 4]
a[0] = 2
print(a)

[2, 2, 3, 4]

反转

# 反转列表
a = [1, 2, 3, 4]
a.reverse()
print(a)

[4, 3, 2, 1]

统计

# 求列表最大值
a = [1, 2, 3, 4]
print(max(a))

4

# 求列表最小值
a = [1, 2, 3, 4]
print(min(a))

1

# 统计值在列表中出现的次数
a = [1, 2, 3, 4, 4, 4]
print(a.count(4))

3

# 计算列表的长度
a = [1, 2, 3, 4]
print(len(a))

4

# 列表从小到大排序
a = [2,4,1,3]
a.sort()			# [1, 2, 3, 4]

# 列表从大到小排序
a = [2,4,1,3]
a.sort(reverse=True)	# [4, 3, 2, 1]

第十一章 元祖

1.元祖的定义

• 元祖由（）包围，元素以逗号隔开
• 特点
  • 有序
  • 不可变
• 如果元祖只有一个元素，必须加逗号以示区分

# 当元祖只有一个元素时
a =(1)       # 不加逗号类型就不是元祖了
print(a)
print(type(a))

b = (1,)     # 只有一个元素时，要加逗号区分
print(b)
print(type(b))

1
<class 'int'>
(1,)
<class 'tuple'>

2. 元祖的常见方法

# 元祖转为列表
a = (1, 2, 3)
b = list(a)
print(b)

[1, 2, 3]

# 列表转元祖
a = [1, 2, 3]
b = tuple(a)
print(b)

(1, 2, 3)

# 求元祖的最大值
a = (1, 2, 3)
print(max(a))

3

# 求元祖的最小值
a = (1, 2, 3)
print(min(a))

1

# 求元祖的长度
a = (1, 2, 3)
print(len(a))

3

第十二章 字典

1.字典的定义

• 字典用{}包围，元素以逗号隔开
• 字典中的数据必须以键值对的形式存在
• 键不可重复，值可以重复（若键重复，只会记住该键对应的最后一个值）
• 特点
  • 无序
  • 可变

# 定义一个字典
student = {"name":"zhangsan", "age":18}
print(student)
print(type(student))

{'name': 'zhangsan', 'age': 18}
<class 'dict'>

2. 字典的常用方法

获取值

# 根据键获取值
student = {"name":"zhangsan", "age":18}
print(student["name"])

zhangsan

修改值

# 根据键修改值，如果值不存在则添加
student = {"name":"zhangsan", "age":18}
student["age"] = 19
print(student)

student["sex"] = "boy"
print(student)

{'name': 'zhangsan', 'age': 19}
{'name': 'zhangsan', 'age': 19, 'sex': 'boy'}

删除值

# 根据键删除键值对
student = {"name":"zhangsan", "age":18}
student.pop("age")
print(student)

{'name': 'zhangsan'}

# 随机删除一组键值对,以元祖形式返回被随机删除的键值对
stu1 = {"name":"zhangsan", "age":18, "sex":"boy"}
stu2 = stu1.popitem()
print("随机删除的是：")
print(stu2)
print("元祖中键值对少了一个：")
print(stu1)

随机删除的是：
('sex', 'boy')
元祖中键值对少了一个：
{'name': 'zhangsan', 'age': 18}

获取键

# 获取键
stu1 = {"name":"zhangsan", "age":18, "sex":"boy"}
stu2 = stu1.keys()
print(stu2)

dict_keys(['name', 'age', 'sex'])

获取值

# 获取值
stu1 = {"name":"zhangsan", "age":18, "sex":"boy"}
stu2 = stu1.values()
print(stu2)

dict_values(['zhangsan', 18, 'boy'])

获取键值对

# 获取键值对
stu1 = {"name":"zhangsan", "age":18, "sex":"boy"}
stu2 = stu1.items()
print(stu2)

dict_items([('name', 'zhangsan'), ('age', 18), ('sex', 'boy')])

第十三章 选择语句

• 语句格式：
  • if 条件：
    • 条件满足要做的事情1
    • 条件满足要做的事情2
    • ...
  • else：
    • 条件不满足时要做的事情1
    • 条件不满足时要做的事情2
    • ...

1. if-else

#  判断能否进入酒吧，18岁以上能进入，18岁以下禁止进入
age = int(input('请输入您的年龄：'))

if age>=18:
     print('欢迎光临魅力四射~')
else:
     print('抱歉，您不能进入！')

2. elif

• 格式：
  • if xxx1:
    • 事情1
  • elif xxx2:
    • 事情2
  • elif xxx3:
    • 事情3

elif必须和if一起使用，否则会出错

# 判断成绩等级
# 优秀：90 <= 成绩 <= 100
# 良好：80 <= 成绩 < 90
# 中等：70 <= 成绩 < 80
# 一般：60 <= 成绩 < 70
# 不及格：0 <= 成绩 < 60
score = 95
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("本次考试，成绩不及格！")
                                       

练习：季节判断

month = int(input('Month:'))
if month in [3,4,5]:
  print('春季')
elif month in [6,7,8]:
  print('夏季')
elif month in [9,10,11]:
  print('秋季')
elif month in [12,1,2]:
  print('冬季')
else:
  print('输入不合法')
  

month = int(input("请输入月份："))
if month >= 3 and month <= 5:
    print("你输入的{}月份是春天".format(month))
elif month >= 6 and month <= 8:
    print("你输入的{}月份是夏天".format(month))
elif month >= 9 and month <= 11:
    print("你输入的{}月份是秋天".format(month))
elif month ==12 or month == 1 or month == 2 :
    print("你输入的{}月份是冬天".format(month))
else:
    print("月份输入不规范,请重新输入！")

3. if嵌套

• 格式

  • if 条件1:

    • 满足条件1 做的事情1
    • 满足条件1 做的事情2
    • ...(省略)...
    • if 条件2:
      • 满足条件2 做的事情1
      • 满足条件2 做的事情2
      • ...(省略)...

age = 17
food = 'no'
if age>=18:
    if food=='yes':
        print('您带了酒水，不能进入')
    else:
        print('欢迎光临')
    

4. if应用：猜拳游戏

# 猜拳游戏
import random

player = input("请输入：剪刀（0） 石头（1） 布（2）：")

player = int(player)      # 把输入的字符串转为整型

computer = random.randint(0,2)   # 随机生成一个在0-2之间的数

print("玩家输入：{}, 电脑输入：{}".format(player, computer))  # 测试

if (player == 0 and computer == 2) or (player == 1 and computer == 0) or (player == 2 and computer == 1):
    print("获胜，哈哈，你太厉害了！")
elif player == computer:
    print("平局哦，要不要再来一局")
else:
    print("你输了，不要走，决战到天亮！")

第十四章 循环语句

1. 程序的三大执行

• 1.顺序执行
• 2.选择执行
  • if else
• 3.循环执行

2. while循环

• 格式
  • while 条件：
    • 满足条件做的事情
• 先判断再执行

打印1-10之间的数字

# 打印1-10之间的数字

# print(1)
# print(2)
# ...

# num = 1
# print(num)

# num = num + 1             找出需要重复执行的代码
# print(num)                在上面加上while

# num = num +1
# print(num)

i = 1
while i<=10:
    print(i)
    i = i + 1
    
    
# 这样的程序就叫循环执行

1
2
3
4
5
6
7
8
9
10

# 打印1-20之间的数
i = 1
while i<=20:
    print(i)
    i = i + 1    # 这句如果忘了写，就会一直打印1，陷入了一个死循环
                 # 这句不写，语法没错，但是逻辑错了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. while嵌套

• 格式
  • while 条件：
    • 条件满足时做的事情
    • ...
    • while 条件2：
      • 条件2满足时做的事情
      • ...

# 举例
'''
给个任务：执行下面的动作10次
1.站起来
2.转5个圈
3.坐下
站起来坐下一共执行10次
转圈一共转了50个

用while来写：
while 条件：
    1.站起来
    while 执行5次：
        2.转1个圈
    3.坐下
'''

'\n给个任务：执行下面的动作10次\n1.站起来\n2.转5个圈\n3.坐下\n站起来坐下一共执行10次\n转圈一共转了50个\n\n用while来写：\nwhile 条件：\n    1.站起来\n    while 执行5次：\n        2.转1个圈\n    3.坐下\n'

打印一个三角形

'''
*
**
***
****
*****

分析：
有五行，每行的东西不一样
既要控制行，又要控制列
做不到？
先做一个简单的
先打印一个类似，再去修改，程序不是一次就写好的
先打印出一个矩形

'''

'\n*\n**\n***\n****\n*****\n\n分析：\n有五行，每行的东西不一样\n既要控制行，又要控制列\n做不到？\n先做一个简单的\n先打印一个类似，再去修改，程序不是一次就写好的\n先打印出一个矩形\n\n'

三角形无法一步到位打印出来，先打印矩形

# 打印矩形

# i = 1
# while i<=5:
#     print("*****")
#     i = i + 1

# i = 1
# while i<=5:
#     j = 1
#     while j<=5:
#         print("*")            # print打印默认换行了，怎么做到不换行？
#         j = j + 1
#     i = i + 1

# i = 1
# while i<=5:
#     j = 1
#     while j<=5:
#         print("*", end="")       # 加上end=‘’，打印不换行，但是*全在一行里了     
#         j = j + 1
#     i = i + 1

i = 1
while i<=5:
    j = 1
    while j<=5:
        print("*", end="")           
        j = j + 1
    print('')                      # 等到里边的while结束了，也就是打印了一行5个星号后，换行
    i = i + 1

*****
*****
*****
*****
*****

打印三角形

# 打印三角形
i = 1
while i<=5:
    j = 1
    while j<=i:             # 第一行一个，第二行两个...正好与i的值一致，并且i的值不受内循环影响
        print("*", end="")           
        j = j + 1
    print('')                     
    i = i + 1

*
**
***
****
*****

打印九九乘法表

# 打印九九乘法表
# i = 1
# while i<=9:
#     j = 1
#     while j<=i:             
#         print("X*Y=Z ", end="")           # 先把格式换上去
#         j = j + 1
#     print('')                     
#     i = i + 1

i = 1
while i<=9:
    j = 1
    while j<=i:             
        print("{}*{}={}\t".format(j,i,j*i), end="")      #加上一个\t对齐     
        j = j + 1
    print('')                     
    i = i + 1

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	

4. for循环

• 格式
  • for 变量 in 序列：
    • 执行语句
• 作用：遍历对象

遍历字符串

# 遍历字符串
name = 'zhangsan'

for i in name:
    print(i)

z
h
a
n
g
s
a
n

遍历列表

name = ['zhangsan', 'lisi', 'wangwu']

for i in name:
    print(i)

zhangsan
lisi
wangwu

遍历字典

# 遍历字典
stu = {'name':'zhangsan', 'age':18, 'sex':'man'}

# 遍历建和值
for key, value in stu.items():
    print(key, ':', value)
    
print('-'*50)

# 遍历键
for key in stu.keys():
    print('key=', key)

print('-'*50)

# 遍历值
for value in stu.values():
    print('value=', value)

name : zhangsan
age : 18
sex : man
--------------------------------------------------
key= name
key= age
key= sex
--------------------------------------------------
value= zhangsan
value= 18
value= man

打印1-10之间的数字

for i in range(1,11):
    print(i)

打印矩形

# 打印矩形
for i in range(1,9):
    for j in range(1,9):
        print("*", end="")
    print("")

打印三角形

# 打印三角形
for i in range(1,9):
    for j in range(1,i+1):
        print("*", end="")
    print("")
for i in range(1,1):
    print("开始打印rang1-1")
    print(i)   #根本就没有值

*
**
***
****
*****
******
*******
********

打印九九乘法表

# 打印九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print("{}*{}={}".format(j,i,j*i), end="\t")
    print("")
  

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	

for if 嵌套

# for if 嵌套
# 打印列表里的所有姓名
# 如果是wangwu，就提示，他中奖了
name = ["zhangsan", "lisi", "wangwu"]
for i in name:
    print(i)
    if i == "wangwu":
        print("恭喜你中奖了！")
    else:
        print("不好意思，你没中奖！")
    

zhangsan
不好意思，你没中奖！
lisi
不好意思，你没中奖！
wangwu
恭喜你中奖了！

注意：if while 同样可以嵌套

for循环练习题

1. 获取任意字符串的长度

s = 'name'  # 定义字符串
num = 0     # 定义长度为0
for i in s:
	num += 1 # 每循环一次，num加1
print(num)

4

2. 给出任意一个字符串，打印出该字符串中的字母个数以及数字个数

str = input('请输入需要统计的字符串：')
letter = 0
num = 0
for i in str:
    if i in 'abcdefghijklmnopqrstuvwxyzABC':
        letter += 1
    elif i in '1234567890':
        num += 1
print('这个字符串中有%d字母，%d个数字' %(letter, num))

3. 生成10个的斐波那契数列

# 从1开始，后面的数是前面两数之和
# 1  1  2  3  5
a, b = 0, 1
nums = []
for i in range(10):
    nums.append(b)
    a, b = b, a+b
print(nums)

4. 求1-100之间的所有偶数和

sum = 0
for i in range(2,101,2):
    sum += i
print(sum)

sum2 = 0
for i in range(1,101):
    if i%2==0:
        sum2+=i
print(sum2)

5. 计算2-3+4-5+6-7+8....100的值

num = 0
for i in range(2, 101):
    if i%2==0:
        num += i
    else:
        num -= i
print(num)

第十五章 函数

1. 函数的定义

• 把具有独立功能的代码块组织成一个小模块

格式

def 函数名()：
   函数代码

2. 函数的文档注释

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

def GuShi():
    '''这个函数用来打印一首古诗'''
    print('百日依山尽')
    print('黄河入海流')
    print('欲穷千里目')
    print('更上一层楼')
    
help(GuShi)

Help on function GuShi in module __main__:

GuShi()
    这个函数用来打印一首古诗

3. 函数的参数

• 需求：定义一个函数，用来计算两个数之和

3.1 函数不带参数

• 不带参数只能固定计算函数里定义好的值

# 定义一个函数用来计算两个数之和
def add2num():
    a = 1
    b = 2
    c = a + b
    print(c)

add2num()

3

3.2 函数的形参和实参

• a,b叫形参（形式参数）：定义函数时的参数
• 1,2叫实参（实际参数）：实际调用时的参数
• 在调用函数时，用实参（1,2）替换形参（a,b），再去执行函数里面的代码

# 由于需要计算的值不固定，所以定义函数时携带两个参数
def add2num(a,b):      # a，b  形式参数
    c = a + b
    print(c)
    
add2num(1,2)           # 1,2  实际参数

3.3 函数参数的传递

3.3.1 位置传递

# 参数按照位置顺序传入
def add2num(a,b):      # a，b  形式参数
    c = a + b
    print(c)
    
add2num(1,2)           # 1,2  实际参数

3.3.2 关键字传递

# 指定形参的值，位置可以不按照形参顺序
def add2num(a,b):      # a，b  形式参数
    c = a + b
    print(c)
    
add2num(b=1,a=2)           # 1,2  实际参数

3.3.3 函数参数的默认值

• 函数参数在定义时可以给默认值，如果调用函数时没有传入实参，就使用参数的默认值
• 注意：拥有默认值的参数一般放在最后一个参数的位置，否则会报错

# 函数参数的默认值
def add2num(b, a=1):      # a，b  形式参数，注意：拥有默认值的参数a，应该放在参数的最后一个位置
    c = a + b
    print(c)
    
add2num(2)           # 1,2  实际参数

4. 函数的返回值

• 函数在执行完成后，一般情况下都会产生一个结果，使用return将这个结果返回给调用者，这就是返回值
• 函数中如果没有定义return，那么返回值为空（None）
• 函数只要执行到return就不会继续往下执行

# 用return返回结果给调用者
def add2num(a,b):
    return a + b

c = add2num(1,2)
print(c)

3

函数没有return，返回None

def add2num(a,b):
    c = a + b

result = add2num(1,2)
print(result)

None

只要执行了return，后续代码将不会执行

def add2num(a,b):
    c = a + b
    
    return c
    
    c -= 1
    
    

result = add2num(1,2)
print(result)

3

5. 局部变量与全局变量

• 全局变量：定义在函数外部的变量，在整个代码文件都生效
• 局部变量：定义在函数内部的变量，只在函数内部生效

全局变量

a = 100          # 全局变量定义在函数外，作用于整个文件

def printNum():
    print(a)     # 在函数内也可以调用该变量

printNum()

100

局部变量

def printNum():
    b = 100       # 局部变量定义在函数内部，只作用于函数内
    print(b)
printNum()
print(b)          # 函数外部无法调用局部变量，错误提示为该变量未定义

100

global

• 使用global可以声明变量为全局变量

def printNum():
    global b      # 使用global声明变量为全局变量
    b = 100       # 局部变量定义在函数内部，只作用于函数内
    print(b)
printNum()
print(b)          # 函数外部无法调用局部变量，错误提示为该变量未定义

100
100

6. 函数的跨文件使用

• 函数封装好以后，可以在其他文件导入并使用
• 导包的方式为：from 文件名 import 函数名

第十六章 文件操作

1. 打开文件

使用open（file，mode）函数可以打开/新建文件

open（）函数参数定义如下：

• file：文件名
• mode：文件打开模式
  • r：只读模式
  • w：写入模式，文件不存在可以自动创建
  • a：追加模式，文件不存在可以自动创建

2. 关闭文件

使用close（）函数可以关闭文件

使用closed可以判断文件是否已经关闭

• 已关闭：返回True
• 未关闭：返回False

3. 文件写入

使用write（str）将数据写入文件中

4. 文件读取

read（）

• read（）可以一次性读取文件中的所有内容
• read（n），n表示数字，读取前n个内容
• 注意：如果多次使用read，会从上次读取的位置继续往后读取，而不是从头开始读取

file2 = open('test.txt', 'r')
txt = file2.read()   # 读取文件,一次性读取所有内容
txt = file2.read(2)   # read中可以填数字，填数字几就是读取前几个字符
txt2 = file2.read(2)  # 如果多次使用read，那么会从上次读取的位置继续往后读取
file2.close()

readlines（）

• readlines（）：按行读取所有内容，返回列表

file2 = open('test.txt', 'r')
content = file2.readlines()  # readlines，按行读取, 返回列表类型
file2.close()

5. 中文处理

在文件中写入 中文 时可能会出现 乱码 现象，这时将指定文件的编码格式为utf-8，即可解决该问题

f = open(r'test2.txt', 'w', encoding='utf-8')   # encoding=utf-8  指定编码格式为utf-8
f.write('中国很强！')
f.close()

6. 文件的自动关闭

使用with open结构打开文件，在文件操作结束后可以自动关闭文件

with open('test.txt', 'r') as f:   # as是当做的意思
    print(f.read())   
    print(f.closed)   # 文件操作未完成前，查看文件关闭状态，返回False
print(f.closed)       # 文件操作完成后，查看文件关闭状态，返回True

第十七章 异常处理

1. 捕获异常

当代码出现异常时，会抛出异常并且停止运行，如果希望代码在出现异常后暂时忽略这个异常继续往后执行，则需要捕获异常

捕获异常的格式：

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

案例：

print('开始执行啦~')
try:
    f = open('你好啊.txt', 'r')
except Exception as e:
    print('这里的代码出问题了，问题是：{}'.format(e))
else:
    print('恭喜你，没有任何问题')
finally:
    print('无论怎么样，我都会执行！')
print('执行结束啦~')

2. 抛出异常

当希望代码在指定情况下出现异常，则需要抛出异常

抛出异常的方法为：raise Exception('错误提示')

print('程序开始啦~')
num = int(input('请输入一个大于100整数：'))
if num <= 100:
    raise Exception('您输入的数字不符合要求，请重新输入！')
else:
    print('输入成功！')
print('程序结束啦~')

第十八章 模块

1. 定义

本质就是一些函数或者类的集合

2. 导入模块的方法

• import 模块名
• from 模块 import 函数

3. 安装模块

3.1 使用pip安装

• 在命令行输入：pip install 模块名
• 查看所有已安装模块：pip list

3.2 手动安装

• 下载模块的压缩包，官网是：pypi.org
• 将压缩包解压，在解压目录打开命令行
• 在命令行输入：python setup.py install
• 安装第三方模块的路径是：C:\Python37\Lib\site-packages

4. 常用模块

时间

import time

# 获取当前时间
print(time.ctime())
# 获取当前时间，并且按照指定格式   2019/10/16 15:19 时间戳
print(time.strftime('%Y-%m-%d %H:%M:%S'))
# 休眠2秒
time.sleep(2)

OS（系统操作）

import os

# 获取当前路径
print(os.getcwd())

# 创建/删除目录
os.mkdir('test')
os.rmdir('test')

# 删除文件
os.remove('test.txt')

json

json是一种广泛使用的轻量数据格式，文件后缀为.json

读取json

import json

c = json.loads('{"name":"zhangsan"}')  # 将字符串格式的json数据转换为dict
print(type(c))

生成json

a = {"name":"zs", "age":18}  			# 定义字典
print(type(a))                            
a = json.dumps(a)                            # 将dict转换成json格式的数据
print(type(a))

第十九章 面向对象

1. 面向过程与面向对象的关系

• 面向过程：按照业务逻辑从上往下编写代码（养鸭子---烤鸭子---吃鸭子）
• 面向对象：将数据跟函数绑定到一起，定义成类，通过类生成多个对象（直接去烤鸭店买烤鸭）
• 面向对象代码思想可以减少代码冗余，提高代码使用效率，从而提高开发效率

2. 类和对象

• 类是泛指一类事物（狗，猫，人... ...）
• 对象是单指某一个具体的事物（xx家的狗）

3. 类的组成部分

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

4. 定义类

定义狗类

class Dog():
    # pass             # 占位符
    # 属性
    # 方法
    def eat(self):
        print('狗正在吃东西~')

    def run(self):
        print('狗正在跑~')

根据类 生成对象

xiaoha = Dog()    # 实例化，生成一条狗叫xiaoha
xiaoha.eat()     # 调用类中的方法
xiaoha.run()

5. 类的初始化

在类中使用__init__方法进行自动化，并将类属性定义在该方法中

类属性与self绑定，这样就可以在其他方法中使用该属性

class Dog():
    # 属性
    def __init__(self):    # 初始化函数，一般在里面写属性，一定会自动运行
        self.color = "黑色"   # 通过self绑定属性值，这样就可以在其他方法中使用该属性
        self.weight = 10

6. 类的继承

如果一个类是一个大类中的一小类，那么这个类可以继承这个大类

被继承的类叫 父类，继承的类的叫 子类

子类继承父类以后有如下特点：

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

class Dog():						# 这是父类
    def __init__(self, color, weight):   
        self.color = color   
        self.weight = weight
    def eat(self):
        print('{}的狗正在吃东西~'.format(self.color))

    def run(self):
        print('{}kg的狗正在跑~'.format(self.weight))

class HaShiQi(Dog):     # 将父类名称写在括号中即可继承父类
    def chai_jia(self):
        print('哈士奇正在拆家~')  #  子类新增父类没有的方法

    def eat(self):                 # 子类通过定义与父类同名的方法达到修改目的，使用自己的而不使用父类的
        print('{}的哈士奇正在吃东西'.format(self.color))

erha = HaShiQi('黑白', 20)
erha.eat()     #  子类使用父类的方法
erha.chai_jia()  # 子使用自己独有的方法