本教程的知识点为：计算机组成 计算机是由什么组成的？ 1. 硬件系统： 2. 软件系统： 目标 运算符的分类 1. 算数运算符 2. 赋值运算符 3. 复合赋值运算符 判断语句和循环语句 if嵌套 1. if嵌套的格式 2. if嵌套的应用 if嵌套执行流程 容器：字符串、列表、元组、字典 字符串介绍 一. 认识字符串 1.1 字符串特征 字符串输出 容器：字符串、列表、元组、字典 列表的相关操作 1添加元素("增"append, extend, insert)1 append extend 容器：字符串、列表、元组、字典 字典的常见操作1 1查看元素1 2修改元素2 3添加元素3 函数介绍 1什么是函数1 小总结: 函数定义和调用 1定义函数1 多函数程序的基本使用流程 1. 使用全局变量 2. 使用函数的返回值、参数 3. 函数嵌套调用 函数返回值(二) 函数应用：学生管理系统 递归函数 1什么是递归函数1 2递归函数的作用2 看阶乘的规律 文件操作介绍 1什么是文件1 2文件的作用2 文件的打开与关闭 1打开文件1 面向对象编程介绍 面向对象 1. 概述 2. 生活举例 类和对象 init()方法 说明： 问题： 有参数的__init__()方法 说明： 继承介绍以及单继承 1. 现实中的继承 2. 程序中的继承 单继承：子类只继承一个父类 说明： super()的使用 问题： 知识点： 私有权限 面向对象三大特性：封装、继承、多态 静态方法和类方法 1. 类方法 2. 静态方法 总结 异常 模块 1Python中的模块1 2import2 3from…import3 注意
完整笔记资料代码->：https://gitee.com/yinuo112/Backend/tree/master/Python/嘿马python基础入门全体系教程/note.md
感兴趣的小伙伴可以自取哦~
全套教程部分目录：
部分文件图片：
容器：字符串、列表、元组、字典
学习目标:
- 能够说出容器类型有什么用
- 能够说出常用 Python 容器的名字
- 能够说出切片语法的用途
- 能够说出容器中的索引指的是什么
- 能够说出如何定义一个字符串
- 能够说出字符串容器的特性
- 能够说出至少5个字符串方法名字和作用
- 能够使用切片语法获得指定索引区间的子串
- 能够说出如何使用 while 和 for 循环来遍历字符串
- 能够说出如何定义一个列表
- 能够说出列表容器和字符串容器的区别
- 能够说出至少5个列表方法名字和作用
- 能够使用切片语法获得列表指定索引区间的元素
- 能够说出如何使用 while 和 for 循环来遍历列表中的元素
- 能够说出如何定义一个列表
- 能够说出元组和列表的区别
- 能够说出如何使用 while 和 for 循环来遍历元组中的元素
- 能够说出元组支持哪些操作
- 能够说出如何定义一个字典
- 能够说出字典和列表的区别
- 能够说出如何使用 for 循环来遍历列表中的键、值和键值对
- 能够说出字典键和值的特点
字典的常见操作1
<1>查看元素1>
除了使用key查找数据，还可以使用get来获取数据
demo:
info = {'name':'吴彦祖','age':18}
print(info['age']) # 获取年龄
# print(info['sex']) # 获取不存在的key，会发生异常
print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
<2>修改元素2>
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
demo:
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
newId = input('请输入新的学号')
info['id'] = int(newId)
print('修改之后的id为%d:'%info['id'])
结果:
<3>添加元素3>
demo:访问不存在的元素
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
print('id为:%d'%info['id'])
结果:
如果在使用 变量名['键'] = 数据时，这个“键”在字典中，不存在，那么就会新增这个元素
demo:添加新的元素
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
# print('id为:%d'%info['id'])#程序会终端运行，因为访问了不存在的键
newId = input('请输入新的学号')
info['id'] = newId
print('添加之后的id为:%d'%info['id'])
结果:
请输入新的学号188
添加之后的id为: 188
<4>删除元素4>
对字典进行删除操作，有一下几种：
- del
- clear()
demo:del删除指定的元素
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
print('删除前,%s'%info['name'])
del info['name']
print('删除后,%s'%info['name'])
结果
demo:del删除整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s'%info)
del info
print('删除后,%s'%info)
结果
demo:clear清空整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前,%s'%info)
info.clear()
print('清空后,%s'%info)
结果
字典的常见操作2
<1>len()1>
测量字典中，键值对的个数
<2>keys2>
返回一个包含字典所有KEY的列表
<3>values3>
返回一个包含字典所有value的列表
<4>items4>
返回一个包含所有（键，值）元祖的列表
<5>has_key （Python3 已取消）5>
dict.has_key(key)如果key在字典中，返回True，否则返回False
遍历
通过for ... in ... 我们可以遍历字符串、列表、元组、字典等
注意python语法的缩进
1. 字符串遍历
>>> a_str = "hello itcast"
>>> for char in a_str:
... print(char,end=' ')
...
h e l l o i t c a s t
2. 列表遍历
>>> a_list = [1, 2, 3, 4, 5]
>>> for num in a_list:
... print(num,end=' ')
...
1 2 3 4 5
3. 元组遍历
>>> a_turple = (1, 2, 3, 4, 5)
>>> for num in a_turple:
... print(num,end=" ")
1 2 3 4 5
4. 字典遍历
<1> 遍历字典的key（键）1>
<2> 遍历字典的value（值）2>
<3> 遍历字典的项（元素）3>
<4> 遍历字典的key-value（键值对）4>
4. 想一想，如何实现带下标索引的遍历
>>> chars = ['a', 'b', 'c', 'd']
>>> i = 0
>>> for chr in chars:
... print("%d %s"%(i, chr))
... i += 1
...
0 a
1 b
2 c
3 d
字典的扩展
有序字典:OrderDcit
我们先看一段代码, 此代码运行在 Python3.5 版本中:
# 创建无序字典
my_dict = dict()
# 向字典中添加元素
my_dict['one'] = 1
my_dict['two'] = 2
my_dict['three'] = 3
my_dict['four'] = 4
print(my_dict)
输出结果(不固定):
{'three': 3, 'two': 2, 'four': 4, 'one': 1}
输出结果并不是按照我们创建字典、添加元素的顺序输出, 这是由于 dict 是无序的. 如果我们想最终打印输出的顺序和我们操作时的顺序保持一致, 我们就需要使用有序字典:
from collections import OrderedDict
# 创建有序字典
my_dict = OrderedDict()
# 向字典中添加元素
my_dict['one'] = 1
my_dict['two'] = 2
my_dict['three'] = 3
my_dict['four'] = 4
print(my_dict)
输出结果:
OrderedDict([('one', 1), ('two', 2), ('three', 3), ('four', 4)])
在 Python3.6 版本中, dict 字典已经经过优化, 变为有序字典. 并且字典所占用的内存占用减少了20％到25％.
第一段代码在 Python3.6 运行下, 输出结果如下:
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
集合
目标
- 创建集合
- 集合数据的特点
- 集合的常见操作
一. 创建集合
创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典。
s1 = {10, 20, 30, 40, 50}
print(s1)
s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)
s3 = set('abcdefg')
print(s3)
s4 = set()
print(type(s4)) # set
s5 = {}
print(type(s5)) # dict
特点：
- 集合可以去掉重复数据；
- 集合数据是无序的，故不支持下标
二. 集合常见操作方法
2.1 增加数据
- add()
s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1) # {100, 10, 20}
因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。
- update(), 追加的数据是序列。
s1 = {10, 20}
# s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)
2.2 删除数据
- remove()，删除集合中的指定数据，如果数据不存在则报错。
s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)
- discard()，删除集合中的指定数据，如果数据不存在也不会报错。
s1 = {10, 20}
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)
- pop()，随机删除集合中的某个数据，并返回这个数据。
s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)
2.3 查找数据
- in：判断数据在集合序列
- not in：判断数据不在集合序列
s1 = {10, 20, 30, 40, 50}
print(10 in s1)
print(10 not in s1)
公共方法
目标
- 运算符
- 公共方法
- 容器类型转换
一. 运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典 |
1.1 +
# 1. 字符串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) # aabb
# 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) # [1, 2, 10, 20]
# 3. 元组
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) # (10, 20, 100, 200)
1.2 *
# 1. 字符串
print('-' * 10) # ----------
# 2. 列表
list1 = ['hello']
print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
# 3. 元组
t1 = ('world',)
print(t1 * 4) # ('world', 'world', 'world', 'world')
1.3 in或not in
# 1. 字符串
print('a' in 'abcd') # True
print('a' not in 'abcd') # False
# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1) # True
print('a' not in list1) # False
# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1) # False
print('aa' not in t1) # True
二. 公共方法
| 函数 | 描述 |
|---|---|
| len() | 计算容器中元素个数 |
| del 或 del() | 删除 |
| max() | 返回容器中元素最大值 |
| min() | 返回容器中元素最小值 |
| range(start, end, step) | 生成从start到end的数字，步长为 step，供for循环使用 |
| enumerate() | 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。 |
2.1 len()
# 1. 字符串
str1 = 'abcdefg'
print(len(str1)) # 7
# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1)) # 4
# 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1)) # 5
# 4. 集合
s1 = {10, 20, 30}
print(len(s1)) # 3
# 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1)) # 2
2.2 del()
# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)
# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) # [20, 30, 40]
2.3 max()
# 1. 字符串
str1 = 'abcdefg'
print(max(str1)) # g
# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1)) # 40
2.4 min()
# 1. 字符串
str1 = 'abcdefg'
print(min(str1)) # a
# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1)) # 10
2.5 range()
# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
print(i)
# 1 3 5 7 9
for i in range(1, 10, 2):
print(i)
# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
print(i)
注意：range()生成的序列不包含end数字。
2.6 enumerate()
- 语法
enumerate(可遍历对象, start=0)
注意：start参数用来设置遍历数据的下标的起始值，默认为0。
- 快速体验
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
print(i)
for index, char in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{char}')
三. 容器类型转换
3.1 tuple()
作用：将某个序列转换成元组
list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(s1))
3.2 list()
作用：将某个序列转换成列表
t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}
print(list(t1))
print(list(s1))
3.3 set()
作用：将某个序列转换成集合
list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))
print(set(t1))
注意：
- 集合可以快速完成列表去重
- 集合不支持下标
推导式
目标
- 列表推导式
- 字典推导式
- 集合推导式
一. 列表推导式
作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。
列表推导式又叫列表生成式。
1.1 快速体验
需求：创建一个0-10的列表。
- while循环实现
# 1. 准备一个空列表
list1 = []
# 2. 书写循环，依次追加数字到空列表list1中
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)
- for循环实现
list1 = []
for i in range(10):
list1.append(i)
print(list1)
- 列表推导式实现
list1 = [i for i in range(10)]
print(list1)
1.2 带if的列表推导式
需求：创建0-10的偶数列表
- 方法一：range()步长实现
list1 = [i for i in range(0, 10, 2)]
print(list1)
- 方法二：if实现
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
1.3 多个for循环实现列表推导式
需求：创建列表如下：
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
- 代码如下：
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
二. 字典推导式
思考：如果有如下两个列表：
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
如何快速合并为一个字典？
答：字典推导式
字典推导式作用：快速合并列表为字典或提取字典中目标数据。
2.1 快速体验
- 创建一个字典：字典key是1-5数字，value是这个数字的2次方。
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}
- 将两个列表合并为一个字典
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
- 提取字典中目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
# 需求：提取上述电脑数量大于等于200的字典数据
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1) # {'MBP': 268, 'DELL': 201}
三. 集合推导式
需求：创建一个集合，数据为下方列表的2次方。
list1 = [1, 1, 2]
代码如下：
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) # {1, 4}
注意：集合有数据去重功能。
