“”"
1.安装软件
2.环境变量的配置
变量名 变量值
Path 应用程序所在的路径(可执行的应用程序 xxx.exe 所在的文件夹)
3.DOS常用命令的使用
3.1 盘符切换
盘符:
3.2 进入文件夹
cd 路径
3.3 展示文件夹
dir
tree
3.4 清除屏幕
cls
3.5 自动补全名称
tab
4.变量
定义(在定义时,要给出初始值) 初始化
重新赋值
5.标识符(变量名)
要求:
可以有字母(包含中文),数字,下划线
数字不能开头,不能为系统的关键字,大小写敏感
关键字(保留字/敏感字)
35个
查看方式:
import keyword
print(keyword.kwlist)
如何更好的命名:
1.见名知意
2.驼峰命名法
大驼峰 MaxValue
小驼峰 maxValue
下划线连接 max_value
python中的数据类型:
数值类型:bool,int,float,complex
字符串:str
复合类型:list,tuple,dict,set
运算符:
优先级以及结合性
数学运算符
+
-
*
/
//
%
**
赋值运算符
简单的赋值
a = 1
复合的赋值
+=
-=
*=
/=
%=
**=
//=
a %= b ==>>> a = a % b
比较运算符
操作数(一般情况下,要求类型一致),比较结果(bool)
>
<
>=
<=
==
!=
age = 10
8 < age < 100
逻辑运算符
and
要求两个条件都满足,结果为True
or
要求两个条件有一个满足,整个结果就为True
not
如果条件为真,加上not 就变成假
“”"
a = 0
v = ‘a’ > 10 # TypeError: ‘>’ not supported between instances of ‘str’ and ‘int’
print(v)
“”"
数值类型之间类型转换:
1.强制转换
由高到低的转换,需要强制转换
2.自动转换
由低到高这时候的类型转换属于自动转换
bool < int < float < complex
bool
int
float
complex
其他类型之间的转换:
常用的转换功能:
int() 转换为整数
float() 转换为小数
str() 转换为字符串
chr()
将unicode编码值 转换为其对应的字符串
ord()
得到字符串对应的unicode编码值
两个函数可以实现互逆操作
eval()
将字符串转数字的时候,会根据字符串是整型,还是小数来进行自动匹配
list()
tuple()
set()
“”"
# # 自动转换
# x = True
# a = 1
# b = 2.5
# c = a + b
# print(type(c))
# print('---------------')
# d = x + a
# print(type(d))
# print('---------------')
# e = x + b
# print(type(e))
# print('---------------')
# # 复数 实部+虚部
# y = 2 + 3j
# print(type(y))
# z = a + y
# print('--------======')
# print(type(z))
# print(z)
#
# print('**'*30)
# # 强制转换
# g = int(b)
# print(type(g))
# h = bool(b)
# print(type(h))
# ch = chr(20002)
# ch = chr(65)
# ch = chr(97)
# print(ch)
# print(type(ch))
# v = ord('宋')
# v = ord('A')
# print(v)
# str1 = '123'
# str1 = '123.5'
str1 = '[1,2,3]'
# 将字符串转换为整数
# v1 = int(str1)
# v1 = float(str1)
v1 = eval(str1)
print(v1)
print(type(v1))
“”"
\n 换行
输出:
print(要输出的内容)
换行的控制问题
print(‘xxx’,end = ‘’)
格式化的输出:
print('name:%s age:%i')
%s:表示字符串
%i/%d:表示整型
%f:表示小数,默认保留小数点后6位,最后一位四舍五入
%g: 可以表示整数,也可以保留小数,如果是小数处理的时候,只保留认为有意义的数据
输入:
v = input(‘输入提示’)
不论输入的是什么类型的数值,变量v接收到的值,都是str类型
“”"
# name = '小明'
# age = 18
# tel = 13800000000
# print('我叫%s,今年%i岁 手机号:%s,风华正茂,玉树临风'%(name, age, tel), end='\n')
# print('我叫%s,今年%i岁,风华正茂,玉树临风'%(name, age), end='\n')
# print(f'我叫{name},今天{age}岁,手机号:{tel},风华正茂,玉树临风',end='\n')
#
# a = 10
# print('a = %f'%a)
# print('a = %.2f'%a)
#
# PI = 3.1415925535897
# print('PI=%f'%PI)
#
# # b = 2.50000000
# # b = 2.511111111111
# b = 10.0
# print('b=%g'%b)
# name = input('请输入你的姓名')
# print(type(name))
# print(name)
# age = input('请输入你的年龄')
# print(type(age))
# print(age)
需求:从键盘输入两个变量a,b,求和,并打印
a = input('请输入变量a的值')
b = input('请输入变量b的值')
c = int(a) + int(b)
print(type(c))
print(f'和为:{c}')
“”"
变量 组词
语句 造句
函数 一段作文
类 整篇文章
语句结构:
顺序结构
从上往下,从左往右,依次执行
分支结构
案例练习:
未成年人上网 (网咖)
骰子大小 1-6 [1-3] [4-6]
随机模块的使用
import random
n = random.randint(a,b)# 生成a-b之间的随机数,包含a跟b
用户登录
默认注册好的用户名
acc = ‘abc’
pw = ‘123’
输入用户名,输入密码
if 用户名对 同时 密码也对:
登录成功
判断结构(向左走,向右走)
1.单分支
2.双分支
3.多分支
循环结构
重复(鬼打墙)
“”"
顺序结构
# print('HelloWorld1')
# print('HelloWorld2')
# print('HelloWorld3')
从键盘你的年龄,根据年龄来判断是否可以上网
# age = input('请输入你的年龄')
# # 数据类型转换的问题
# age = int(age)
# if 18 <= age <= 100:
# # if age >= 18 and age <= 100:
# print('xx网咖欢迎您')
#
# if age < 18 or age > 100:
# print('回家洗洗睡')
需求:生成随机数,判断大小问题
import random
n = random.randint(1,6)# 1 <= n <= 6
print(n)
if 1 <= n <= 3:
print('小')
if 4 <= n <= 6:
print('大')
“”"
注册用户名,密码
输入用户名,密码,完成校验登录
双分支语法:
if 条件:
条件成立执行的代码
else:
条件不成立执行的代码
需求:根据年龄上网问题: 改成双分支的判断形式
需求:骰子点数大小问题,改成双分支的判断形式
“”"
注册
usename_register = input('请输入注册的用户名:')
password_register = input('请输入注册的密码:')
# 验证登录
username_login = input('请输入之前注册的用户名:')
password_login = input('请输入之前注册的密码')
# 登录校验-登录成功 and
if username_login == usename_register and password_login == password_register:
print('登录成功')
else:
print('登录失败')
# 登录校验-登录失败 (1.用户名不对,密码对 2.用户名对,密码不对 3.都不会)
# if (username_login != usename_register and password_login == password_register) or (username_login == usename_register and password_login != password_register) or (username_login != usename_register and password_login != password_register):
# print('用户名/密码有误')
“”"
双分支结构:
点数大小问题
三元条件表达式:
“”"
import random
n = random.randint(1, 6)
# if 1 <= n <= 3:
# result = '小'
# else:
# result = '大'
# 三元条件表达式
result = '小' if 1 <= n <= 3 else '大'
print(result)
“”"
分支结构:
1.单分支
if 条件:
条件成立执行的代码
2.双分支
if 条件:
条件成立执行的代码
else:
条件不成立执行的代码
3.多分支
if 条件1:
条件1满足执行
elif 条件2:
条件2满足执行
elif 条件3:
条件3满足执行
…
else:
其他情况
需求:
根据你考试的分数,给出对应的评级
A:[90,100]
B:[80,90)
C:[70,80)
D:[60,70)
E: < 60
需求: 输入一个月份,打印对应的季节
“”"
score = input(‘请输入你考试的分数:’)
自动转换
score = eval(score)
if 90 <= score <= 100:
print('A')
elif 80 <= score < 90:
print('B')
elif 70 <= score < 80:
print('C')
elif 60 <= score < 70:
print('D')
elif 0 <= score < 60:
print('E')
else:
print('分数有误')
“”"
需求: 输入一个月份,打印对应的季节
1.输入 input()
2.类型转换
3.多分支
春:
3-5
夏:
6-8
秋:
9-11
冬:
12,1,2
“”"
month = input('请输入一个月份1-12:')
month = int(month)
if 3 <= month <= 5:
print('春天')
elif 6 <= month <= 8:
print('夏天')
elif 9 <= month <= 11:
print('秋天')
***# elif month == 12 or month == 1 or month == 2:***
elif month == 12 or 1 <= month <= 2:
print('冬天')
else:
print('输入有误')
“”"
分支的嵌套使用
if 外部条件:
外部条件成立
if 内部条件:
内部条件成立
else:
内部条件不成立
else:
外部条件不成立
生活案例:
if 有车票:
进站安检
if 安检合格:
可以进站候车
else:
安检不合格无法进站
else:
无法进入安检
开发过程中的使用:
“”"
“”"
骰子点数大小问题:
猜(输入)
你猜的结果跟开奖的结果做比较,中还是没中
1.先猜
2.摇点数
3.开奖
需求:
输入用户名密码
if 用户名密码都正确:
直接打印出模拟生成验证码:
if 验证码是否正确:
登录成功
else:
验证码有误
else:
用户名或密码有误
“”"
i
mport random
# 猜的点数
result_guess = input('请猜大/小:')
# 生成随机点数
n = random.randint(1, 6)
# 比较处理
if result_guess == '大':
if 4 <= n <= 6:
print(f'恭喜中奖:猜的大,开的{n}')
else:
print('很遗憾,猜的大,开的小')
else:
if 4 <= n <= 6:
print('很遗憾,猜的小,开的大')
else:
print(f'恭喜中奖,猜的小,开的{n}')
“”"
需求:
输入用户名密码
if 用户名密码都正确:
直接打印出模拟生成验证码:
if 验证码是否正确:
登录成功
else:
验证码有误
else:
用户名或密码有误
“”"
import random
usename_register = 'abc'
password_register = '123'
# 验证登录
username_login = input('请输入之前注册的用户名:')
password_login = input('请输入之前注册的密码')
***if username_login == usename_register and password_login == password_register:***
# 接入短信接口,可以实现为手机号发送短信
rand_code = random.randint(1000,9999)
rand_code = str(rand_code)
print(rand_code)
code_input = input('请输入你接到到的验证码')
if rand_code == code_input:
print('登录成功')
else:
print('验证码有误')
else:
print('用户名/密码有误')
“”"
1.顺序结构
2.分支结构
3.循环结构
重复
while
语法:
while 条件:
条件成立执行(执行完毕之后,会继续判断条件)
死循环:
while True:
while 1 < 2:
执行
案例:
打印10次HelloWorld
练习:
打印1-100之间所有的偶数
for
“”"
# print('HelloWorld')
# print('HelloWorld')
# print('HelloWorld')
# i = 1
# while i <= 10:
# print(f'HelloWorld{i}')
# i = i + 1
想打印1-100之间的数字
# i = 1
# while i <= 100:
# print(i)
# i += 1
# i = 0
# while i <= 100:
# print(i)
# i += 2
打印10-1所有的数字
# i = 10
# while i >= 1:
# print(i)
# i -= 1
“”"
1.数据类型的转换
自动转换
由低到高自动转换
bool->int->float->complex
强制转换
不同的数值类型之间,由高到低,需要强制转换
不同的数据类型之间,需要强制转换
int()
float()
str()
bool()
---------
list()
set()
dict()
tuple()
----------
chr(code)
ord()
---------
eval()
1.根据字符串类型自动转换对应的数值类型
2.将字符串表达式转换为实际表达式并进行运算,得出运算结果
2.输出
print(‘xxx’)
格式化输出:
%s
%i/%d
%f
%g
name = ‘xx’
age = 18
print(‘我叫%s,今年%i’%(name,age),end=’’)
print(f’我叫{name},今年{age}’)
print(f’我叫{“小明”}’)
3.输入
v = input(‘输入提示’)
不论输入的是什么内容,v都是以字符串的形式存在的
4.语句结构
顺序结构
从上往下,从左往右依次执行
分支结构
判断,选择
单分支
if 条件:
条件成立执行
双分支
if 条件:
条件成立执行
else:
条件不成立执行
多分支
if 条件1:
条件1成立执行
elif 条件2:
条件2成立执行
...
else:
除以上条件之外,会执行
循环结构
判断,重复
while 条件:
条件成立执行
让条件趋向终止
“”"
# v = input('请输入一个整数或小数')
# print(type(v))
# print(v)
# print('---'*20)
# v = eval(v)
# print(type(v))
# print(v)
print(f'我叫{"小明"}')
“”"
1.输入一个考试分数,判断考试结果是否为通过,如果分数>= 60,通过,
否则,结果为不通过(分别使用双分支,以及三元条件表达式)
“”"
# score = input('请输入你的考试分数')
# score = eval(score)
# v = '通过'if score >= 60 else '不通过'
# print(v)
“”"
3.循环输入5个100以内的正整数,打印出输入的最大值,最小值,总和
“”"
max_value = 0
min_value = 100
sum = 0
i = 1
while i <= 5:
n = int(input(f'请输入第{i}个100以内的整数'))
if n > max_value:
max_value = n
if n < min_value:
min_value = n
# 将输入的数字累加到变量sum中
# sum = sum + n
sum += n
print(f'当前的最大值为:{max_value}')
print(f'当前的最小值为:{min_value}')
i += 1
print(f'最终的最大值为:{max_value}')
print(f'最终的最小值为:{min_value}')
print(f'所有数字的和为:{sum}')
“”"
5.使用一个循环打印出所有的英文字母(大小写)
A-Z
65-90
a-z
97-122
chr()
“”"
# i = 65
# while i <= 90:
# print(chr(i),end=' ')
# print(chr(i+32),end=' ')
# i += 1
“”"
6.打印以下数列 1/3 , 2/5 ,3/7 , 4/9…前10项,并求出总和
“”"
# i = 1
# while i <= 10:
# j = 2 * i + 1
# print(f'{i}/{j}',end=',')
# i += 1
# for i in range(10):
# j=2*i+1
# print(f'{i}/{j}',end=',')
“”"
7.使用循环如下图形:
*
**
“”"
# for i in range(1,6):
# print('*'*i)
# i = 1
# while i <= 5:
# # * 可以实现字符串的重复
# print('*'*i)
# i += 1
# print('--'*20)
“”"
8.猜拳游戏(玩10次):
while 终止条件:
cmp = 计算机随机生成(0,2) #0.石头 1.剪刀 2.布
you = 输入(0.石头 1.剪刀 2.布)
if 计算机获胜的情况:
print(计算机得1分)
elif 平局:
print(‘平局’)
else:
print(‘你得1分’)
print(统计结果)
“”"
import random
# 记录你赢的次数
a = 0
# 计算机赢的次数
b = 0
# 平局次数
c = 0
i = 1
while i <= 10:
cmp = random.randint(0,2)
you = int(input('计算机思考完毕,该你了:0-石头 1-剪刀 2-布'))
# 比输赢(1.从用户的输赢的角度来考虑 2.可以从用户出的什么角度来考虑)
***if (you == 0 and cmp == 1) or (you == 1 and cmp == 2) or (you == 2 and cmp == 0):***
print('you win!')
a += 1
elif you == cmp:
print('平局')
c += 1
else:
print('you lose!')
b += 1
i += 1
else:
# 与while循环结合使用的else 会在循环正常结束后执行
print(f'你获胜{a}次,平局{c}次,输了{b}次,胜率{a/10*100}%')
“”"
循环结构:
while循环
语法:
while 条件:
循环体
条件趋向终止
for循环
语法:
for 变量 in range():
循环体
range(stop)
range(start,stop,step)
start:表示起点,可以不写,默认从0开始
stop:表示终点(但是不包含终点这个数)
step:表示的步长,默认为1
循环控制的关键字
break:
结束当前循环
continue
跳过本次循环
for
pass
else
pass
“”"
打印1-5的整型数字
# i = 1
# while i <= 5:
# print(i,end=' ')
# i += 1
# for i in range(100,0,-22):
# if i>=36:
# continue
# if i==22:
# continue
# if i==8:
# break
# print(i,end='\t')
# for i in range(1,6,1):
# print(i,end=' ')
# 不写步长,默认为1
# for i in range(1,6):
# print(i,end=' ')
# 不写起点,默认从0开始
# for i in range(6):
# print(i,end=' ')
# i = 5
# while i > 0:
# print(i,end=' ')
# i -= 1
# print(f'while循环已经结束,i={i}')
# list1=[111,2,3,4,555,3,2,121]
# list2=list1[-1:-3:-1]
# print(list2)
#
# print('-------------------------')
#
# for i in range(5,0,-1):
# print(i,end=' ')
# print(f'循环已经结束,i={i}')
使用for循环打印100以内的偶数
# for i in range(2,101,2):
# print(i,end=' ')
循环生成10以内的随机数字,直到生成8结束(循环次数未知)
# import random
# n = 0
# i = 0
# while n != 8:
# n = random.randint(1,10)
# i += 1
# print(f'第{i}次生成的随机数字为{n}')
break 与 continue的使用
# for i in range(10):
# if i == 5:
# # break
# continue
# print(i,end=' ')
for-else的使用
# for i in range(10):
# if i == 5:
# break
# # if i == 9:
# # continue
# print(i,end=' ')
# else:
# print('循环正常结束')
# print('循环结束')
“”"
嵌套分支:
嵌套循环:
外循环
内循环
while
while
while
for
for
for
for
while
执行:
外循环执行一次,内循环从头到尾执行一遍
“”"
# for i in range(5):
# print(f'外循环,i = {i}')
# for j in range(5):
# print(f'内循环,j = {j}')
# i = 0
# while i < 5:
# print(f'i = {i}')
# j = 0
# while j < 5:
# print(f'j={j}')
# j += 1
# i += 1
嵌套循环中的break
break 结束所在的循环
# end = False
# for i in range(5):
# print(f'外循环,i = {i}')
# if end:
# break
# for j in range(5):
# if j == 2:
# end = True
# break
# print(f'j = {j}')
# for i in range(1,11):
# if i%2==0:
# continue
# for j in range(11-i):
# if j%2==1:
# continue
# for k in range(2*i-1):
# print(i,end='\t')
# print()
***# for i in range(100,200,2):***
***# if i%3==0 and i%7!=0 or i%7==0 and i%3!=0:***
***# for j in range(200-i):***
***# continue***
***# print(i,end='\t')***
“”"
使用嵌套循环,打印矩阵时,外循环控制行,内循环控制列
**
“”"
# print('*****')
# print('*'*5)
# count1 = 5
# count0 = 6
# count1 = 8
# for j in range(count0):
# for i in range(count1):
# print('*', end=' ')
# else:
# print()
***# for i in range(1,10):
# # 每一行中的内容
# for j in range(i):
# print('? * ? = ?',end=' ')
# print()***
# for i in range(5):
# for j in range(i+1):
# print('*',end='')
# print()
# a=5
# b=6
***# for i in range(a):***
***# for j in range(b):***
***# if i==0 or j==b-1 or j==0 or i==a-1:***
***# print('*',end='\t')***
***# else:***
***# print('',end='\t')***
# print()
# a=5
# for i in range(a):
# for j in range(a-i):
# print('*',end='\t')
# print()
#运行后
*****
****
***
**
*
打印菱形
# *
# ***
# *****
# *******
# *********
# *******
# *****
# ***
# *
for i in range(1,5):
for j in range(5-i):
print(’ ‘,end=’’)
for k in range(2*i-1):
print(’*’,end=’’)
print()
for i in range(5,0,-1):
for j in range(5-i):
print(’ ‘,end=’’)
for k in range(2*i-1):
print(’*’,end=’’)
print()
for i in range(1,4):
for j in range(4-i):
print(’ ‘,end=’’)
for k in range(2i-1):
print(’’,end=’’)
print()
for i in range(4,0,-1):
for j in range(4-i):
print(’ ‘,end=’’)
for k in range(2i-1):
print(’’,end=’’)
print()
# for i in range(1,10):
# # 每一行中的内容
# for j in range(i):
*# print(f’{j+1} * {i} = {(j+1)i}’,end=’\t’)
# print()
“”"
打印空心矩阵
-
*
-
*
-
*
-
*
打印等腰三角形
*
“”"
count0 = 10
count1 = 15
for j in range(count0):
for i in range(count1):
# 如果是第一行或者最后一行第一列或者最后一列 j控制行 i控制列
# if j == 0 or j == count0-1 or i == 0 or i == count1-1:
print(’*’, end=’ ')
else:
print(’ ‘,end=’ ')
else:
print()
打印等腰三角形
for i in range(1,5):
# 打印‘ ’
for k in range(5-i):
print(’ ‘,end=’’)
# 打印*
for j in range(2*i-1):
print(’*’,end=’’)
print()
“”"
练习 打印1-100之间所有数字,按指定的要求的分行
分行示例如下:
1
2 3
4 5 6
7 8 9 10
…
“”"
# 用来几个数字进行换行
count = 1
# 计数器
count2 = 0
for i in range(1,101):
print(i,end=’\t’)
count2 += 1
if count2 == count:
print()
# 每换行一次,控制换行的个数+1
count += 1
# 计数器清0,保证下次从头开始数
count2 = 0
a=1
a1=0
for i in range(2,101,2):
print(i,end=’\t’)
a1+=1
if a1==a:
print()
a+=1
a1=0
a2=1
a3=0
for i in range(100,0,-1):
print(i,end=’\t’)
a3+=1
if a3==a2:
print()
a2+=1
a3=0
“”"
列表(list)
可以存储多个任意类型的数据
引入
存储某个学生的信息
名字 年龄 性别
定义
stu_info = []
内存结构
栈上存地址
堆上存数据
求列表长度(列表中元素的个数)
len(list)
列表特点:
可以重复,有序
索引问题
可以访问列表中的具体元素
list[index]
注意:
索引越界问题
IndexError
索引范围:
【0,len(list)-1】
序列操作
相加
重复
切片
遍历
序列解包
多个变量名来接收元素
“”"
定义
stu0_info = [‘王铁锤’,18,‘女’,170,98]
通过系统提供的功能添加元素
stu0_info.append(1001)
print(type(stu0_info))
print(f’列表stu0_info的内存地址为:{id(stu0_info)}’)
stu1_info = stu0_info
print(f’列表stu1_info的内存地址为:{id(stu1_info)}’)
print(f’名称:{stu0_info[0]}’)
IndexError: list index out of range
print(stu0_info[5])
stu1_info[2] = ‘男’
print(stu1_info)
print(stu0_info)
list1 = [1,2]
list2 = [2,3]
list3 = list1 + list2
print(list3)
可以通过* 完成列表的重复创建
list4 = list1 * 2
print(list4)
print(’–’*30)
列表中元素的遍历(打印列表中所有的元素)
i = 0
while i < len(stu0_info):
print(stu0_info[i])
i += 1
for i in range(len(stu0_info)):
print(stu0_info[i])
for 变量 in 列表:
for i in stu0_info:
print(i)
“”"
1.for循环
for 变量 in range():
pass
range(stop)
range(start,stop,step)
start: 表示开始
默认为0
stop: 表示结束
step: 表示步长
默认步长为1
步长可以为负数,表示递减
for
else:
循环正常结束会执行的代码
break:
结束当前循环
continue:
表示跳过本次循环
2.嵌套循环
外循环
内循环
执行顺序:
外循环执行一次,内循环从头到尾执行一遍
3.列表的基本使用
list
概念:
可以存储任意多个不同类型的数据
定义:
list1 = []
特点:
有序,元素可以重复
内存:
两块内存,栈上存地址(引用),堆上存数据
长度:
len(list)
访问元素:
通过索引值
list[index]
索引范围
[0,len(list)-1]
拼接:
v = [1,2]+[3,4]
重复:
v = [1,2]*2
尾部添加:
list.append(e)
“”"
l0 = [1,1,1,4,5,6,7]
l = [1,2,3,4,5,6,7]
for i in range(len(l)-3):
l1 = l[i:i+4]
if l1 == l0[i:i+4]:
print(f’中出号码为{l1}’)
break
print(l1)
“”"
1.从键盘录入行为5,列为5,打印如下图形:
-
*
-
*
-
*
“”"
a = int(input(‘请输入行’))
b = int(input(‘请输入列’))
for i in range(a):
for j in range(b):
# if i == 0 or i == a-1 or j == 0 or j == b-1:
print(’*’,end=’ ')
else:
print(’ ‘,end=’ ')
print()
“”"
2.循环生成10个100以内的随机数,存储到列表中,找出最大值,最小值
“”"
import random
# 定义一个列表,用来存储所有的数据
nums_list = []
for i in range(10):
n = random.randint(1,100)
nums_list.append(n)
print(’–’*20)
print(nums_list)
假设列表中的最大值为第一个元素
max_value = nums_list[0]
# 假设列表中的最小值为第一个元素
min_value = nums_list[0]
循环将当前最大值与其他数据一次比较,找出最大的,最小的
for i in range(1,len(nums_list)):
if max_value < nums_list[i]:
max_value = nums_list[i]
if min_value > nums_list[i]:
min_value = nums_list[i]
调用系统功能直接实现:
max_value = max(nums_list)
min_value = min(nums_list)
print(f’{nums_list}中最大值为:{max_value} 最小值为:{min_value}’)
“”"
3.生成一个长度为4的验证码,存储到列表中,要求前两个为小写字母,后两个为0-9之间的数字
“”"
import random
code_list = []
for i in range(4):
if i < 2:
# 生成对应的随机数,使用chr转换为字母
code = chr(random.randint(97,122))
code_list.append(code)
else:
n = str(random.randint(0,9))
code_list.append(n)
print(code_list)
“”"
斐波那契数列
4.有一个数列(例如:1,1,2,3,5,8,13…),使用循环求出数列的第n个数,n为从键盘录入的
“”"
n = int(input(‘请输入要求的第几个数’))
使用循环实现
a = 1
b = 1
i = 3
while i <= n:
a, b = b, a + b
print(b,end=’\t’)
i += 1
使用列表实现
list1 = [1,1]
i = 3
while i <= n:
list1.append(list1[-2]+list1[-1])
i += 1
print(list1[n-1])
import sys
print(sys.getsizeof(list1))
“”"
5.从键盘录入一个数字,找出这个数字的所有约数,存储到列表中
约束: 能被整除的数
“”"
nums_list = []
n = int(input(‘请输入一个数字’))
for i in range(1,n+1):
# 判断n是否能被i整除
if n % i == 0:
nums_list.append(i)
print(nums_list)
“”"
6.录入两个数字,找出两个数字的最大公约数
“”"
a = int(input(‘请输入一个整数’))
b = int(input(‘请输入另外一个整数’))
存储a的所有约数
nums_list1 = []
存储b的所有约数
nums_list2 = []
求出a的所有约数
for i in range(1,a+1):
if a % i == 0:
nums_list1.append(i)
求出b的所有约数
for i in range(1,b+1):
if b % i == 0:
nums_list2.append(i)
print(nums_list1)
print(nums_list2)
遍历其中一个列表的数据(从后往前进行遍历)
for i in range(len(nums_list1)-1,-1,-1):
# 如果这个约数在另外一个列表
if nums_list1[i] in nums_list2:
print(f’最大公约数:{nums_list1[i]}’)
# 找到之后直接结束
break
“”"
7.模拟随机生成一组福利彩票10选3的号码(不能有重号)
1-10的号码选3个数
“”"
import random
nums_list = []
while len(nums_list) < 3:
n = random.randint(1,10)
if n not in nums_list:
nums_list.append(n)
print(nums_list)
“”"
8.手动选择一组号码,存储到列表中(不能有重号,如果输入的为重号,则提示重新输入)
“”"
nums_list1 = []
while len(nums_list1) < 3:
n = int(input(‘请输入1-10之间的任意数字’))
if n not in nums_list1:
nums_list1.append(n)
else:
print(‘号码重复,重新输入’)
else:
print(f’你输入的号码为:{nums_list1}’)
“”"
9.统计出两组号码(手选号码与随机号码)中的相同号码,存储到新列表中
“”"
遍历其中一个列表,看这个列表中的元素是否在另外一个列表中,如果在,添加到新列表中
nums_list2 = []
for n in nums_list:
if n in nums_list1:
nums_list2.append(n)
使用嵌套循环 找出两个列表中相同的元素
nums_list2 = []
for n in nums_list:
for m in nums_list1:
if n == m:
nums_list2.append(n)
break
print(f’相同号码为:{nums_list2}’)
“”"
列表的切片:
意义:
可以基于一个列表,通过切片操作,得到一个新的列表
注意:
基于索引值操作
语法:
list[start:stop:step]
start:
表示切片的开始位置
可以省略不写,如果不写,默认从头开始
stop:
表示切片的结束位置(不包含终点)
可以省略不写,如果不写,默认到最后(包含最后一个)
step:
步长
可以省略,如果不写,默认值为1
“”"
char_list = [‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’]
切片出前三个
sub_list1 = char_list[0:3]
sub_list1 = char_list[0:3:1]
sub_list1 = char_list[:3]
print(type(sub_list1))
print(sub_list1)
切出最后三个
sub_list2 = char_list[4:6]
切片操作中,不存在越界问题
sub_list2 = char_list[4:7]
sub_list2 = char_list[4:700]
sub_list2 = char_list[4:]
sub_list2 = char_list[len(char_list)-3:]
print(char_list[-3:])
print(sub_list2)
print(’—’*20)
步长的问题
sub_list3 = char_list[0::]
sub_list3 = char_list[::2]
print(sub_list3)
print(’----’*20)
步长为负数的问题:
sub_list4 = char_list[3:0:-1]# a b c d e f g
print(sub_list4)
快速得到一个倒序的列表
sub_list5 = char_list[::-1]
print(sub_list5)
“”"
操作列表的常用功能
添加元素
append(obj)
尾部条件元素
insert(index,obj)
指定位置插入指定元素
待验证效率问题
extend(list)
将一个列表中的所有元素,逐个加入到列表一个列表
删除元素
list.remove(要删除的元素)
del list[index]
list.pop(index)
list.clear()
查询元素
修改元素
“”"
list1 = [1,2]
list1.append(3)
print(list1)
list1.insert(0,4)
print(list1)
list2 = [7,8]
将列表2中的所有元素追加到列表1中
list1.extend(list2)
print(list1)#[4, 1, 2, 3, 7, 8]
基于两个列表中的数据,创建一个新的列表
list3 = list1 + list2
list1.remove(8)
print(list1)# [4, 1, 2, 3, 7]
list1.pop(0)
print(list1)# [1, 2, 3, 7]
del list1[0]
print(list1)# [ 2, 3, 7]
list1.clear()
print(list1)# []
“”"
查询
value in list
列表是否包含目标元素
value not in list
列表中是否不包含目标元素
index(obj)
查看目标元素在列表中首次出现的索引值,如果没有,报错
count(obj)
查看目标元素出现的次数
修改
赋值:
list[index] = value
翻转:
list.reverse()
将列表翻转(对源数据操作)
reversed(list)
得到一个翻转的新列表
排序:
list.sort()
按自然顺序(对源数据排序)
list.sort(reverse=True)
按从大到小顺序排序
sorted(list)
按自然顺序排序(得到一个排序后的新列表,源数据不变)
“”"
查找操作
list1 = [1,2,3,4,3,3,3,3]
v = 1 in list1
# v = 1 not in list1
print(v)
i = list1.index(3)
# i = list1.index(100)# ValueError: 100 is not in list
print(i)
# j = list1.count(3)
j = list1.count(100)
print(j)
修改操作
list1 = [1,10,2,4,3,0]
list1[0] = 100
将元素1修改为100(1、是否有该元素 2、找索引 3、按索引修改)
if 1 in list1:
i = list1.index(1)
list1[i] = 100
翻转
list1.reverse()
print(list1)
list2 = reversed(list1)
print(list1)
for i in list2:
print(i)
排序
list1.sort(reverse=True)# 对源数据进行排序
print(list1)
得到一个排序后新列表,源数据不变
list2 = sorted(list1)
print(list1)
print(list2)
“”"
嵌套列表
可以存储任意多个不同数据类型的集合(有序序列)
# 使用列表存储一个学生的信息
stu = [‘xxx’,18,‘男’]
students = [[‘xxx’,18,‘男’],[‘xxx’,18,‘女’],[‘xxx’,18,‘男’]]
嵌套列表中元素的访问:
list1[][]
嵌套列表的内存结构:
list1 = [[1,2],[3,4]]
需求:
使用列表存储从键盘录入的3个学生,(每个学生包含:姓名,年龄)
“”"
存储3个学生信息
students = [[‘aaa’,12],[‘bbb’,18],[‘ccc’,38]]
访问第二个学生的名字
print(students[1][0])
for i in range(1,4):
print(f’请输入第{i}个学生的信息’)
name = input(‘姓名:’)
age = input(‘年龄:’)
stu = [name,age]
students.append(stu)
print(students)
遍历列表中每一个元素
for i in range(len(students)):
stu_list = students[i]
for e in stu_list:
print(e,end=’ ')
print()
“”"
深浅复制:
列表中自带的功能是浅复制
import copy
copy模块中提供了深浅复制功能
浅复制
copy.copy(x)
深复制
copy.deepcopy(x)
区别:
1.如果列表存储的数据为基本类型,深浅复制没有区别,都是复制一份新的出来
2.如果列表中存储的数据为复合对象(列表中存储的元素为列表,字典,元组…),深浅复制有区别
2.1 浅复制
尽可能复制地址
2.2 深复制
尽可能复制数据
“”"
import copy
list1 = [1,2]
list2 = [3,4]
list3 = [list1,list2]
# 调用列表的复制功能
list4 = list1.copy()
print(id(list1))
print(id(list4))
list4[0] = 100
print(list1)
print(list4)
浅复制一份list3
list5 = copy.copy(list3)
list5 = copy.deepcopy(list3)
通过索引修改值
list5[0][0] = 100
print(list3[0][0])
“”"
列表:
1.列表的切片
list[start:stop:step]
索引值为负值的时候,表示的倒数第几个数
start: 表示索引开始位置
省略不写,默认从0开始
stop:表示结束的索引位置(不包含该位置)
省略不写,默认到最后位置(包含最后一个的)
step:表示步长
不写的情况下,默认值为1
可以为负值
实现列表的反转:
list[::-1]
2.列表的增删查改
增加:
append(obj)
尾部添加元素
insert(index,obj)
在指定位置插入执行的元素
extend(list)
可以将另外一个列表中的元素,逐个添加到当前列表中
删除:
可以根据值删、可以根据索引值删
remove(obj)
pop(index)
del list[index]
clear()
查询:
查询是否包含、查询所在的位置(索引值)
obj in list
not in
count(obj)
index(obj)
得到obj在列表中所在索引值,如果列表中不包含,直接报错
修改:
list[index] = new_value
排序:
list.sort()# 从小到大
list.sort(reverse=True)# 从大到小
sorted(list)
基于源数据(不变)内容,得到一个新的列表(排序后的)
翻转:
list.reverse()
reversed(list)
基于源数据内容(不变),得到一个新的反转后的列表
3.嵌套列表的定义以及使用
列表中的元素,同样也是列表
list1 = [[[10,100],2],[3,4]]
内存:
必须能画出来
嵌套列表中元素的访问:
list[][][]
list1[0][1]
4.列表的复制操作
list.copy()
深浅复制:
import copy
copy.copy() 浅复制
copy.deepcopy() 深复制
二者区别与联系:
对于一般数据,二者同样都是实现复制一份新的出来
区别:
列表中如果存储的数据为复合对象,
浅复制:尽可能的复制引用(地址)
深复制:递归复制所有元素的内容
“”"
list1 = [1,2,3]
list2 = list1
list3 = list1.copy()
hex(地址)
print(hex(id(list1)))
print(hex(id(list2)))
print(hex(id(list3)))
list2 与 list3
“”"
2.循环录入3个学生的学生信息(姓名,年龄,性别,分数),
存储到合理的序列中(使用嵌套列表)
“”"
students = []
count = 3
for i in range(1,count + 1):
print(f’请输入第{i}个学生的信息’)
name = input(‘姓名:’)
age = eval(input(‘年龄:’))
gender = input(‘性别:’)
score = eval(input(‘分数:’))
stu = [name,age,gender,score]
students.append(stu)
print(students)
import time
start_time = time.time()
nums = []
for i in range(100000):
# nums.append(i)
nums.insert(0,i)
end_time = time.time()
print(f’耗时:{end_time-start_time}秒’)
“”"
3.生成一个包含n个(n从系统录入)英文字母(大小均可)的列表,通过对位交换的方式实现列表的反转
“”"
import random
chars = []
n = int(input(‘请输入一个正整数:’))
for i in range(n):
chars.append(chr(random.randint(65,90)))
print(chars)
print(’-----’*20)
需要交换的次数
count = n // 2
for i in range(count):
chars[i],chars[len(chars)-1-i] = chars[len(chars)-1-i],chars[i]
print(chars)
import random
l1 = [1,2,3,4,5,6,7]
l2 = [1,0,3,4,5,6,0]
for i in range(0,7):
sub_list = l2[i:i+6]
if sub_list == l1[i:i+6]:
print(‘二等奖’)
break
if len(sub_list) < 6:
break
print(sub_list)
for i in range(0,7):
sub_list = l2[i:i+4]
if sub_list == l1[i:i+4]:
print(f’四等奖,中出号码:{sub_list}’)
break
if len(sub_list) < 4:
break
“”"
list
list = []
tuple:
概念:
可以存储任意多个不同类型数据的有序集合
特点:
不可变,有序,不唯一
特性操作:
定义:
t = ()
如果存储元素,必须有’,‘
连接
+
重复
*
索引范围
[0,len(t)-1]
访问:
t[index]
存在越界问题
操作:
增加(不支持)
删除(不支持)
查询:
index()
count()
in
not in
修改(不支持)
遍历:
for in
for in range()
while i < len():
t = 1,2,3
这时候t默认为元组类型
dict
set
“”"
t = (1,)
print(type(t))
t2 = (2,)
t3 = t+t2
print(t3)
t4 = t3*2
print(t4)
print(t4[-1])
# print(t4[10]) #IndexError: tuple index out of range
t5 = ()
t5 = (1,2,3)
# del t5[0] # TypeError: ‘tuple’ object doesn’t support item deletion
print(t5)
i = t5.index(2)
print(i)
c = t5.count(2)
print©
print(1 in t5)
t5[0] = 100 # TypeError: ‘tuple’ object does not support item assignment
a, *b = 1, 2, 3
*a, b = 1, 2
print(type(a))
print(a)
print(type(b))
print(b)
print(’—’*20)
# t6 = 1, 2, 3
t6 = 1, 2, 3
print(type(t6))
print(t6)
元组的嵌套
t = ((1,2),(3,4))
t = ([1,2],[3,4])
t = [(1,2),(3,4)]
print(t[0][1])
t6 = (1,2)
基于元组的内容,创建一个新的列表
list1 = list(t6)
print(type(list1))
基于列表的内容创建元组
t7 = tuple(list1)
print(type(t7))
“”"
复合:
list
[]
tuple -> 不可变
()
---------
dict:
字典
映射关系
特点:
对于字典而言,没有索引值,没有默认顺序(无序的,Python2 完全无序, Python3.5之后添加顺序)
Python2之所以存储的数据是无序,取决于底层的数据结构
哈希表(哈希表存储数据的原理)
key唯一(值以后添加的为准)
什么类型可以做key?
一般情况下,建议使用字符串做key
不可变类型都可以做key
基本类型都为不可变类型,tuple
不可变类型 (可以做key)
bool,int,float,str,tuple
可变类型(不能做key)
list,dict,set
作用:
存数据,可以多个数据
定义:
d = {}
存储数据方式:(key:value) 键值对的存储方式
stu_dict = {‘name’:‘xxx’,‘age’:18,‘gender’:‘男’}
访问方式:
d[key]
set
“”"
# 定义一个空字典
d = {}
print(type(d))
# stu_list = [1001,‘xxx’,18,‘男’]
# print(f’姓名:{stu_list[0]} 年龄:{stu_list[1]} 性别:{stu_list[2]}’)
# 定义一个存储3个减值对元素的字典
stu_dict = {‘id’:1001,‘name’:‘xxx’,‘age’:18,‘gender’:‘男’,‘id’:1002}
print(stu_dict)
# print(f’姓名:{stu_dict[0]} 年龄:{stu_dict[1]} 性别:{stu_dict[2]}’)
# 字典中元素的访问,通过key获取对应的值
print(f’学号:{stu_dict[“id”]} 姓名:{stu_dict[“name”]} 年龄:{stu_dict[“age”]} 性别:{stu_dict[“gender”]}’)
# d1 = {65:‘A’,66:‘B’,True:1,3.5:‘PI’,[1,2]:1}
d1 = {65:‘A’,66:‘B’,True:1,3.5:‘PI’,(1,2):1}
print(d1)
# 可变类型数据无法求hash值
#v = hash([1,2,3])
a={‘e’:8,‘o’:9,‘k’:0,‘m’:22,‘b’:88}
“”"
元素的访问:
d[key]
访问的时候,如果没有指定key,则导致keyError
d.get()
访问的时候,如果没有自定key,不会报错,会得到一个None
增:
d[key] = value
setdefault()
update(key=value)
删:
pop()
popitem()随机删除
del
clear
查:
默认情况只能查key
in
not in
改:
d[key] = value
update(key=value)
country.update(IN=‘Indian’,JP=‘123’)
遍历:
keys():
获取字典中所有的key
python2 list
python3 生成器对象
values()
获取字典中所有的value
items()
获取字典中所有的键值对
“”"
country = {‘CN’:‘China’,‘JP’:‘Japan’}
print(country[‘CN’])
KeyError: ‘CH’
print(country[‘CH’])
print(country.get(‘CN’))
print(country.get(‘CH’))
# 首次出现该Key,添加
country[‘EN’] = ‘England’
后续出现该key,修改
country[‘EN’] = ‘America’
# country.setdefault(‘EN’,‘England’)
country.update(IN=‘Indian’,JP=‘123’)
print(country)
# 删除
# v = country.pop(‘IN’)
# print(v)
# # 任意删除一个
country.popitem()
print(country)
del country[‘CN’]
# country.clear()
print(country)
# 查询
print(‘China’ in country)
print(‘CN’ in country)
# 字典的遍历
for k in country:
print(f’国家简称:{k},国家全称:{country[k]}’)
for k in country.keys():
print(f’国家简称:{k},国家全称:{country[k]}’)
all_key = country.keys()
print(type(all_key))
print(all_key)
# 将dict_keys类型转换为列表类型
all_key_list = list(all_key)
print(all_key_list)
all_value = country.values()
print(all_value)
#
for value in country.values():
print(value)
print(’–’*20)
all_item = country.items()
print(all_item)
for i in country.items():
print(i)
for k,v in country.items():
# print(i)
print(k,v)
“”"
集合:Set
定义方式:
s = {}
特点:
无序,唯一
可以存储什么类型的数据?
只能存储不可变类型的数据(等同于字典的key)
集合底层数据结构:
哈希表(添加,删除,查找效率都很高)
存储原理
长度:
len(s)
注意:
集合中没有索引值
遍历:
for in
增
add(elem)
删
remove(elem)
pop()
discard(elem)
clear()
查
in
not in
改s
间接修改(删旧的,添加新的)
使用场景:
快速去重
set(list)
list()
“”"
s = {‘1’,‘a’,10,0,‘x’,1,‘1’,(1,2)}
s = {‘1’,‘a’,10,0,‘x’,1,‘1’,(1,2),[1,2]}
s = {‘1’,‘a’,10,0,‘x’,1,‘1’,(1,2),{‘a’:1,‘b’:2}}
s = set()
print(type(s))
print(s)
v = hash(‘1’)
print(v)# 1193136600182093950, 457057545219557140,7439736106587348287
print(s[0]) # TypeError: ‘set’ object does not support indexing
for i in s:
print(i)
s1 = set()
s1.add(‘a’)
s1.add(‘z’)
s1.add(‘d’)
s1.add(‘f’)
s1.add(1)
print(s1)
删除
s1.remove()
print(s1)
s1.pop()
print(s1)
s1.discard(1)
print(s1)
# list1 = [1,1,2,2,3,4,4]
# 去重列表中重复数据
# s = set(list1)
# print(s)
# 取交集,取反交集,取并集
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
# 取交集
set3 = set1 & set2
print(set3)
# 取反交集
set4 = set1 ^ set2
print(set4)
# 取并集
set5 = set1 | set2
print(set5)
来源:CSDN
作者:return_min
链接:https://blog.csdn.net/return_min/article/details/103585184