学习笔记
一，python是什么
Python是时下最流行、最火爆的编程语言之一
1.简单、易学，适应人群广泛
2. 免费、开源
3. 应用领域广泛
二，解释器
1.pycharm 推荐使用(不用安装各种插件)
2.vs code
三，变量
1.定义变量
my_name = 'TOM'
2.输出变量(使用变量) 使用 print() 打印输出变量
print(my_name)
3.输入 使用 input("提示信息")
1.一般将input接收的数据存储到变量
2.input接收的任何数据默认都是字符串数据类型
str = input('请求输入账户')
print(str)
4.类型转换
1. int() 转换为 整数
str = '12346'
print(type(int(str))) # str type是检测类型的
2. float() 转换为 浮点数
3. str() 转换为 字符串
4. eval() 用来计算在字符串中的有效Python表达式,并返回一个对象
5. tuple() 转换为一个元组
6. list() 转换为一个列表
7. chr() 将一个整数转换为一个Unicode字符
8. ord() 将一个字符转换为它的ASCII整数值
9. hex() 将一个整数转换为一个十六进制字符串
10. oct() 将一个整数转换为一个八进制字符串
11. bin() 将一个整数转换为一个二进制字符串
5.运算符
1.简单运算符
+ 加 1 + 1 输出结果为 2
- 减 1-1 输出结果为 0
* 乘 2 * 2 输出结果为 4
/ 除 10 / 2 输出结果为 5
// 整除 9 // 4 输出结果为2
% 取余 9 % 4 输出结果为 1
** 指数 2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2
() 小括号 小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9
2.赋值运算符
= 赋值
a = b = 10 a变量 和 b变量 都是10
3.复合运算符
+= 加法赋值运算符 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
4.比较运算符
== 判断相等。如果两个操作数的结果相等，则条件结果为真(True)，否则条件结果为假(False)
如a=3,b=3，则(a == b) 为 True
!= 不等于 。如果两个操作数的结果不相等，则条件为真(True)，否则条件结果为假(False)
如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=7,b=3，则(a < b) 为 False如a=3,b=3，则(a >= b) 为 True
<= 运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于，则条件为真，否则为假
如a=3,b=3，则(a <= b) 为 True
5.逻辑运算符
and 布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。
一个为假，皆为假
or 布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。
一个为真，皆为真
not 布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。
取反
四，条件语句 {仔细观察会发现 代码结束 都是靠 空格缩进的}
1.if语法
if True:
print('条件成立执行的代码1')
print('条件成立执行的代码2')
# 下方的代码没有缩进到if语句块，所以和if条件无关
print('我是无论条件是否成立都要执行的代码')
2.多层if
if 条件1:
条件1成立执行的代码1
条件1成立执行的代码2
elif 条件2：
条件2成立执行的代码1
条件2成立执行的代码2
else:
以上条件都不成立执行执行的代码
3.if 案例
age = int(input('请输入您的年龄：'))
if age < 18:
print(f'您的年龄是{age},童工一枚')
elif (age >= 18) and (age <= 60):
print(f'您的年龄是{age},合法工龄')
elif age > 60:
print(f'您的年龄是{age},可以退休')
4.if嵌套
if 条件1：
条件1成立执行的代码
条件1成立执行的代码
if 条件2：
条件2成立执行的代码
条件2成立执行的代码
5.三目运算符----三元表达式
值1 if 条件 else 值2
a = 1
b = 2
c = a if a > b else b
print(c)
五，循环
1.while循环
while 条件:
条件成立重复执行的代码1
条件成立重复执行的代码2
......
1.打印5变媳妇我错了
i = 0
while i < 5:
print('媳妇儿，我错了')
i += 1
print('任务结束')
2.计算1-100累加和
i = 1
result = 0
while i <= 100:
result += i
i += 1
# 输出5050
print(result)
3.计算1-100偶数累加和
i = 1
result = 0
while i <= 100:
if i % 2 == 0:
result += i
i += 1
# 输出2550
print(result)
2.break和continue
1.break 跳出循环
有5给苹果 只能吃3个苹果
i = 1
while i <= 5:
if i == 4:
print(f'吃饱了不吃了')
break
print(f'吃了第{i}个苹果')
i += 1
2.continue 退出本次循环，继续执行下一次重复执行的代码
有5给苹果，吃到3个有虫子，就不吃第三个
i = 1
while i <= 5:
if i == 3:
print(f'大虫子，第{i}个不吃了')
# 在continue之前一定要修改计数器，否则会陷入死循环
i += 1
continue
print(f'吃了第{i}个苹果')
i +=
3.while循环嵌套
while 条件1:
条件1成立执行的代码
......
while 条件2:
条件2成立执行的代码
......
1.一行输出5个星号，重复打印5行
# 重复打印5行星星
j = 0
while j <= 4:
# 一行星星的打印
i = 0
while i <= 4:
# 一行内的星星不能换行，取消print默认结束符\n
print('*', end='')
i += 1
# 每行结束要换行，这里借助一个空的print，利用print默认结束符换行
print()
j += 1
2.打印星号(三角形)
# 重复打印5行星星
# j表示行号
j = 0
while j <= 4:
# 一行星星的打印
i = 0
# i表示每行里面星星的个数，这个数字要和行号相等所以i要和j联动
while i <= j:
print('*', end='')
i += 1
print()
j += 1
3.打印九九乘法表
# 重复打印9行表达式
j = 1
while j <= 9:
# 打印一行里面的表达式 a * b = a*b
i = 1
while i <= j:
print(f'{i}*{j}={j*i}', end='\t')
i += 1
print()
j += 1
4.for循环
1.语法
for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2
......
2.案例
str1 = 'itheima'
for i in str1:
print(i)
3.break
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不打印')
break
print(i)
4.continue
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不打印')
continue
print(i)
5. python的循环居然还有 else 我也是惊讶到了 在此还是记录一些
1.while...else
1.语法
while 条件:
条件成立重复执行的代码
else:
循环正常结束之后要执行的代码
2.案例
i = 1
while i <= 5:
print('媳妇儿，我错了')
i += 1
else:
print('媳妇原谅我了，真开心，哈哈哈哈')
2.for...else
1.语法
for 临时变量 in 序列:
重复执行的代码
...
else:
循环正常结束之后要执行的代码
2.案例
str1 = 'itheima'
for i in str1:
print(i)
else:
print('循环正常结束之后执行的代码')
六，数据序列
1.字符串 '我是字符串'
1.什么是字符串
字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。
a = 'hello world'
2.下标/索引
name = 'abcd'
print(name[0]) #a
print(name[1]) #b
print(name[2]) #c
print(name[3]) #d
3.切片
1.什么是切片
序列[开始位置下标:结束位置下标:步长]
1. 不包含结束位置下标对应的数据， 正负整数均可；
2. 步长是选取间隔，正负整数均可，默认步长为1。
2.实例
name = 'abcd'
print(name[0:2:1]) # ab
print(name[0:2]) # ab
print(name[1:2:1]) # b
print(name[1:]) # bcd
print(name[::2]) #bd
print(name[1::2]) #c
4.常用的操作方法
1.find() : 检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1
字符串序列.find(子串, 开始位置下标, 结束位置下标)
2.index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常
字符串序列.index(子串, 开始位置下标, 结束位置下标)
3.count()：返回某个子串在字符串中出现的次数
字符串序列.count(子串, 开始位置下标, 结束位置下标)
4.replace()：替换
字符串序列.replace(旧子串, 新子串, 替换次数)
5.split()：按照指定字符分割字符串
字符串序列.split(分割字符, num)
6.join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串
字符或子串.join(多字符串组成的序列)
7.capitalize()：将字符串第一个字符转换成大写
8.title()：将字符串每个单词首字母转换成大写
9.lower()：将字符串中大写转小写
10.upper()：将字符串中小写转大写
11.lstrip()：删除字符串左侧空白字符
12.rstrip()：删除字符串右侧空白字符
13.strip()：删除字符串两侧空白字符
14.ljust()：返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串
15.rjust()：返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同
16.center()：返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同
17.startswith()：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查
18.endswith()：：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查
19.isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
20.isdigit()：如果字符串只包含数字则返回 True 否则返回 False
21.isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
22.isspace()：如果字符串中只包含空白，则返回 True，否则返回 False
2.列表 js中的数组 [1,2,3]
1.什么是列表
列表可以一次性存储多个数据，且可以为不同数据类型。
2.下标/索引
name = [a,b,c,d]
print(name[0]) #a
print(name[1]) #b
print(name[2]) #c
print(name[3]) #d
3.遍历列表
1.while 遍历
lists = [1，2，3]
i = 0
while i < len(lists):
print(lists[i])
i += 1
2.for 遍历
lists = [1, 2, 3]
for i in lists:
print(i)
4.列表常用操作方法
1.index()：返回指定数据所在位置的下标
列表序列.index(数据, 开始位置下标, 结束位置下标)
2.count()：统计指定数据在当前列表中出现的次数
列表序列.count(数据)
3.len()：访问列表长度，即列表中数据的个数
len(列表序列)
4.in：判断指定数据在某个列表序列，如果在返回True，否则返回False
5.not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
6.append()：列表结尾追加单个数据
列表序列.append(数据)
7.extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表
列表序列.extend(数据)
8.insert()：指定位置新增数据
列表序列.insert(位置下标, 数据)
9.del 删除
del 列表序列
10.pop()：删除指定下标的数据(默认为最后一个)，并返回该数据
列表序列.pop(下标)
11.remove()：有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的 值，可使用方法remove()
列表序列.remove(数据)
12.clear()：清空列表
列表序列.clear()
13.reverse()：翻转排序
列表序列.reverse()
14.sort()：排序
列表序列.sort()
15.copy()：复制
列表序列.copy()
3.元组 (1.2.3) 元组中没有重复值
1.什么是元组
元组可以存储多个数据，元组内的数据是不能修改的
2.元组的定义
num1 = (1, 2, 3)
num2=(1,)
3.元组的常用方法
1.index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同
2.count()：统计某个数据在当前元组出现的次数
3.len()：统计元组中数据的个数
4.字典 js中的对象，键值对 {'name':'张三','age':19}
1.什么是字典
字典里面的数据是以==键值对==形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可
2.定义字典
num1 = {'name': '张三', 'age': 19}
num2 = {} # 空字典
num3 = dict() # 空字典
3.字典的常用操作
1.下标/key 修改数据
2.del() / del：删除字典或删除字典中指定键值对
3.clear()：清空字典
4.get()：查找数据 如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。
字典序列.get(key, 默认值)
5. keys()：字典的建
6.values()；字典的值
6.items()：字典的每一项
4.字典的遍历
1.遍历字典的元素
names = {'name':'张三','age':19}
for item in names.items():
print(item)
2.遍历字典的键值对
names = {'name':'张三','age':19}
for key,value in names.items():
print(f'{key}=={value}')
5.集合 {1,2,3}
1.什么是集合
集合（set）是另一种标准的 Python 数据类型，它也可用于存储值。它们之间主要的区别在于，集合不同于列表或元组，集合中的每一个元素不能出现多次，并且是无序存储的
2.定义集合
num1 = {1, 2, 3, 5}
num2 = set('12123')
num3 = {}
num4 = set()
3.集合的常用操作方法
1.add()：追加单个数据
2.update()：追加的数据是序列
3.remove()，删除集合中的指定数据，如果数据不存在则报错
4.discard()，删除集合中的指定数据，如果数据不存在也不会报错
5.pop()，随机删除集合中的某个数据，并返回这个数据
6.公共操作 一些操作字符串，列表，元组，字典，集合的公共方法
1.运算符
+ 合并 字符串，列表，元组
* 复制 字符串，列表，元组
in 元素是否存在 字符串，列表，元组，字典
not in 元素是否不存在 字符串，列表，元组，字典
2.方法
len() 计算长度
del / del () 删除
max() 返回最大值
min() 返回最小值
range() 生成从start到end的数字，步长为 step，供for循环使用
enumerate() 给列表、元组或字符串 添加一个索引
enumerate(可遍历对象, start=0)
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
print(i)
for index, value in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{value}')
7.推导式 代码简化
1.什么是推导式
用一行代码，写出循环，达到简化代码
2.列表推导式
1.for循环
lists = []
for i in range(10):
lists.append(i)
print(lists)
2.看上面的for循环4行代码 下面一行代码搞定
lists = [i for i in range(10)]
3.字典推导式
1.给2列表 合并成字典
list1 = ['name', 'age']
list2 = ['张三', 19]
list3 = {}
for i in len(list1):
list3.append({list1[i]: list2[i]})
print(list3)
2.来整个 一行代码
list1 = ['name', 'age']
list2 = ['张三', 19]
list3 = {list1[i]: list2[i] for i in len(list1)}
七，函数
1.什么是函数
函数就是将 一段具有独立功能的代码块 整合到一个整体并命名，在需要的位置 调用这个名称 即可完成对应的需求。
2.定义函数/调用函数
def 函数名(参数):
代码1
代码2
......
def users(): # 定义函数
print('1')
print('2')
print('3')
users() # 调用函数
3.函数的参数
1.形参 定义函数接收的时候 为形参
def lists(a, b): # a,b是形参
r = a + b
print(r)
2.实参 调用函数传参的时候 为实参
lists(1,2) # 1，2是实参
4.函数的返回值
return 终止程序运行并且返回一段数据
def list(a, b):
return a + b
print(list(1,1)) # 2
5.小案例，学员管理系统 ，增加学员，删除学员，修改学员，查看学员，退出系统
info = [] # 定义全局的学员列表
# 定义一个状态栏 显示
def list():
print('1.添加学员')
print('2.删除学员')
print('3.修改学员信息')
print('4.查询学员信息')
print('5.显示所有学员信息')
print('6.退出系统')
# 添加学员
def add_list():
username = input('请输入名称')
age = input('请输入年龄：')
global info # 调用全局变量info
for i in info:
# print(i)
if username == i['username']:
print('该学生已存在')
return
info.append({'username': username, 'age': age})
# 删除学员
def remove_list():
username = input('请求输入要删除的学员昵称：')
global info # 调用全局变量info
for i in info:
if username == i['username']:
info.remove(i)
print('删除成功')
return
else:
print('删除失败')
return
# 修改学员信息 年龄
def modify_list():
username = input('请输入名称')
age = input('请输入年龄：')
global info # 调用全局变量info
for i in info:
if username == i['username']:
print(i)
i['age'] = age
# 查看 学员信息
def info_list():
global info # 调用全局变量info
for i in info:
print(f"{i['username']}===={i['age']}")
# 循环调用
while True:
list() # 调用输出蓝
num = int(input('请输入序号进入对应功能：')) # 输入框
# 判断
if num == 1:
print('添加学员')
add_list()
elif num == 2:
print('删除学员')
remove_list()
elif num == 3:
print('修改学员信息')
modify_list()
elif num == 4:
print('查询学员信息')
info_list()
elif num == 5:
print('显示所有学员信息')
info_list()
elif num == 6:
print('退出系统')
quit() # 退出系统
else:
print('请输入正确的序号')
6.递归 在函数内容调用自身 就是递归函数 （必须写出口不然会报错）
1.调用函数 从 3 加到 1
def func(a):
if a ==1:
return 1
return a + func(a - 1)
print(func(3))
7. lambda表达式 如果函数只有一个返回值，并且只有一句代码， 可以使用lambda 简化代码
1.
lambda 参数列表 ： 表达式
2.两数相加
num=lambda a, b: a + b
print(num(10, 80)) # 90
3.没有参数
num = lambda: 10
print(num) #10
4.默认参数
num = lambda a=10: a
print(num(1)) #1
5.不定长参数
num = lambda *args: args
print(num(1,2,3,45))
6.不定长关键词参数
num = lambda **kwargs: kwargs
print(num({'name': 'son', 'age': 19}))
8.高级函数 把函数作为参数传入，化简代码
1.abs() 取绝对值
print(abs(-10)) #10
2.round() 四舍五入
print(round(1.5)) #2
print(round(1.4)) #1
3.map() 函数func作用到每个列表中
str = [1, 2, 3, 4]
def func(x):
return x + 1
print(map(func, str)) # 返回的是地址
print(list(map(func,str))) # [2,3,4,5]
4.reduce() func必须传入2给参数
import functools
str = [1, 2, 3, 4]
def func(a, b):
return a + b
print(functools.reduce(func, str)) #10
5.filter() 过滤器作用
str = [1, 2, 3, 4, 5]
def func(x):
return x % 2 == 0
print(filter(func,str)) # [2,4]
发表评论