#可以输出数字
print(520)
print(1314)
\#可以输出字符串
print('hello world!')
print("hello world !")
\#可以输出含有运算符的表达式
print("5+3")
print(5+3)
\#可以讲数据输出到文件中，注意点：1、路径中盘符要存在；2、文件file=fp；
fp=open('D:/学习资料/text.txt','a+')
print('helloworld',file=fp)
fp.close()
\#不进行换行输出，即仅仅在一行输出
print('I','can','do','it')
# 开发时间：2022/3/30 11:32
\#转义字符
print('hello\nworld')
print('hello\tworld')
print('helloooo\tworld')#\t水平制表符
print('hello\rworld')#\r回车
print('hello\bworld')#\b退格
print('http:\\www.baidu.com')
print('老师说：\'大家好\'')
\#原字符，不希望字符串中的转义字符起作用，就使用原字符，就是字符串之前加上r，或R
print(r'hello\nworld')
\#注意事项，最后一个字符不能是反斜杠
print(r'hello\nworld')
Print()函数 功能：向目的地输出内容
输出内容：数字、字符串、表达式
目的地：IDLE、控制台、文件
| 转义字符的分类 常表示的字符 | 转义字符 | 备注 | ||
|---|---|---|---|---|
| 换行 | \n | newline光标移到下一行的开头 | ||
| 无法直接表示的字符 | 回车 | \r | return光标移动到本行的开头 | |
| 水平制表符 | \t | tab键，光标移动到下一组4个空格的开始处 | ||
| 退格 | \b | 键盘上的backspace键，回退一个字符 | ||
| 在字符串中有特殊 | 反斜杆 | \ | ||
| 用途的字符 | 单引号 | \’ | ||
| 双引号 | \" | |||
print(chr(0b100111001011000))
print(ord('乘'))
- 变量、函数、类、模块、和其他对象的起的名字就叫标识符
- 规则：
- 字母、数字、下划线
- 不能以数字开头
- 不能是保留字
- 严格区分大小写
\# 开发时间：2022/3/31 9:54
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
变量的定义和使用- 变量由三部分组成
- 标识：标识对象所存储的内存地址。
使用内置函数id（obj）来获取
- 类型：标识的是对象的数据类型，使用内置函数type（obj）来获取
- 值：表示对象所存储的具体数据，使用print（obj）可以将值进行打印输出
- 标识：标识对象所存储的内存地址。
\# 开发时间：2022/3/31 10:10
name='玛利亚'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
- 当多次赋值之后，变量名会指向新的空间
# 开发时间：2022/3/31 10:17
name='玛利亚'
print(name)
name='楚留冰'
print(name)
数据类型
- 常用的数据类型
- 整数类型
int：98 - 浮点数类型
float：3.14159 - 布尔类型：
bool: True\False - 字符串类型：
str:‘人生苦短，我用python’
- 整数类型
数据类型
- 整数类型
- 英文为integer，简写int，可以表示正数、负数和零
- 正数的不同进制表示方式
- 十进制 默认进制
- 二进制 以0b开头
- 八进制 以0o开头
- 十六进制 以0x开头
#整型可以表示为正数、负数和零
n1=521
n2=0
n3=-1314
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#整数可以表示为二进制、十进制、八进制和十六进制
print('二进制',0b10101011) #二进制以0b开头
print('十进制',521)
print('八进制',0o176)#八进制以0o开头
print('十六进制',0x1EAF)#十六进制以0x开头
- 浮点类型
- 浮点数整数部分和小数部分组成
- 浮点数存储不精确性
- 使用浮点数进行计算时，可能会出现小数位数不确定的情况
# 开发时间：2022/3/31 10:46
n1=1.1
print('类型',type(n1))
n2=2.2
print(n1+n2)
n3=2.1
print(n1+n3) #不精确
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2')) #3.3
- 布尔类型
- 用来表示真或假的值
- True表示真，False表示假
- 布尔值可以转化为整数
- True 1
- False 0
# 开发时间：2022/3/31 11:14
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))
#布尔值可以转成整数计算
print(f1+0) #1 1+0的结果为1，True表示1
print(f2+0) #0 0+0的结果为0，False表示0
- 字符串类型
- 字符串又被称为不可变的字符序列
- 可以使用单引号’‘双引号"“三引号”’'"
- 单引号和双引号定义的字符串必须在一行
- 三引号定义的字符串可以分布在连续的多行
str1="人生苦短，我用Python"
str2="人生苦短，我用Python"
str3="""人生苦短，
我用Python"""
str4="""人生苦短，
我用Python"""
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))
| 函数名 | 作用 | 注意事项 | 举例 |
|---|---|---|---|
| str() | 将其它数据类型转成字符串 | 也可用引号转换 | str(123) ‘123’ |
| int() | 将其它数据类型转成整数 | 1、文字类和小数类字符串，无法转成整数；2、浮点数化成整数：抹零取整 | int(‘123’) int(98.2) |
| float() | 将其它数据类型转成浮点数 | 1、文字类无法转成浮点数；2、整数转成浮点数，末尾为.0 | float(‘9.9’)、float(9) |
- 注释
- 在代码中对代码的功能进行解释说明的标志性文字，可以提高代码的可读性
- 注释的内容会被python解释器忽略
- 通常包括三种类型的注释
- 单行注释 以’#'开头，直到换行结束
- 多行注释 并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释
- 中文编码声明注释 在文件开头加上中文声明蛛丝，用一指定的原码文件的编码格式
# 2022/4/3 16:07
#输入功能（单行注释）
print('hello')
'''嘿嘿嘿，
我是
多行注释
'''
#coding:gbk #或utf-8
# 开发人员：
# 2022/4/3 16:09
#python文件默认编码是UTF-8,编码格式声明注释在首行
-
input（）函数的基本使用
-
变量 赋值运算符’=’ input（‘input the number：’）
-
present = input(‘大圣想要声明礼物呢？’)
-
present=input('大圣想要什么礼物呢？')
print(present,type(present))
a=input('请输入一个加数：')
b=input('请输入另一个加数：')
print(type(a),type(b)) #input（）函数是输入一个字符串的数据类型
print(a+b) #此处+起到的是连接作用
a=int(a)
b=int(b)
print(a+b)
- 标准算术运算符 加（+）、减（-）、乘（*）、除（/)、整除（//）
- 取余运算符 %
- 幂运算符 **
print(1+1)#加法运算
print(1-1)#减法运算
print(2*5)#乘法运算
print(1/2)#除法运算
print(11/2)#除法运算
print(11//2)#整除运算
print(11%2)#取余运算
print(2**8)#幂运算 表示2的8次方
print(2**9)#幂运算 表示2的9次方
- 整除运算中注意事项
- 一正一负的整除公式，向下取整
- 余数=被除数-除数*商
print(9//4) #2
print(-9//-4)#2
print(9//-4) #-3
print(-9//4)#-3 一正一负的整除公式，向下取整
print(9%-4) #-3 公式 余数=被除数-除数*商 9-（-4）*（-3） 9-12-->-3
print(-9%4) #3 公式 余数=被除数-除数*商 9-（4）*（-3） -9+12-->3
- 赋值运算符 运算顺序从右到左
- 支持链式赋值 id 属于同一个地址
- 支持参数赋值 +=、-=、*=、/=、//=、%=
- 支持系列解包赋值 a,b,c,=10,20,50 变量个数左右要相同
a=b=c=20 #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))
print('---------支持参数赋值-----------')
a=20
a+=30 #相当于a+=30
print(a)
print(type(a))
a-=10 #相当于a=a-10
print(a)
a*=2
print(a)
a/=3
print(a)
print(type(a)) #float
a//=2
print(a)
a,b,c=20,30,50
print(a,b,c)
#a,b=20,30,50 报错，因为左右变量的个数和值的个数不对应
print('--------交换两个变量的值-------')
a,b=10,20
print('交换之前',a,b)
#交换
a,b=b,a
print('交换之后',a,b)
- 比较运算符的结果为bool类型
# 2022/4/3 20:44
a,b=10,20
print('a>b吗？',a>b) #False
print('a,a<b) #True
print('a<=b吗？',a<=b) #True
print('a>=b吗？',a>=b) #True
print('a==b吗？',a==b) #False
print('a!=b吗？',a!=b) #True
'''
一个 = 称为赋值运算符，==称为比较运算符
一个变量由三个部分组成，标识，类型，值
==比较是标识还是值呢？比较的是值
比较对象的标识使用 is
'''
a=10
b=10
print(a==b) #True 说明，a与b的value相等
print(a is b)#True 说明，a与b的id标识，相等
#以下代码没学过，后面会给大家讲解
list1=[11,22,33,44]
list2=[11,22,33,44]
print(list1==list2)
print(list2 is list1)
print(id(list2))
print(id(list1))
print(a is not b) #False a和b的id标识是不相等的吗
print(list1 is not list2)#True
- 对于布尔值之间的运算
| 运算符 | 运 算 | 数 | 运算结果 | 备注 | |
|---|---|---|---|---|---|
| True | True | True | 当两个运算数为True的时，运算结果才为True | ||
| and | True | False | False | ||
| False | True | False | |||
| False | False | False | |||
| True | True | True | 只要有一个运算数位True，运算结果就为True | ||
| True | False | True | |||
| or | False | True | True | ||
| False | False | False | |||
| not | True | False | 如果运算数为True，运算结果为False | ||
| False | True | 如果运算数为False，运算结果为True |
- 位与& 对应数位都是1，结果数位才是1，否则为0
- 位或| 对应数位都是0，结果数位才是0，否则为1
- 左移位运算符<< 高位溢出舍弃，低位补0
- 右移位运算符>> 低位溢出舍弃，高位补0
print(4&8) #按位与&，
print(4|8) #按位或|，同时为0时结果为0
print(4<<1)#向左移动1位（移动一个位置）相当于乘以2
print(4<<2)#向左移动2位（移动2个位置）
print(4>>1)#向右移动1位，相当于除以2
print(4>>2)#向右移动2位，相当于除以4
- 幂运算》乘除取整取余》加减》移位运算》位与》位或》比较运算符》与或布尔运算》赋值运算
- 顺序结构
- 选择结构 if语句
- 循环结构 while语句、for-in语句
print('-------------程序开始----------')
print('1、把冰箱门打开')
print('2、把大象放冰箱里')
print('3、把冰箱门关上')
print('--------------程序结束---------')
- python一切皆对象，所有对象都有一个布尔值
- 获取对象的布尔值
- 使用内置函数bool（）
- 以下对象的布尔值为False
- False
- 数值（）
- None
- 空字符串
- 空列表
- 空元组
- 空字典
- 空集合
print("-----------以下对象的布尔值均为False------")
print(bool(False))#False
print(bool(0))#False
print(bool(0.0))#False
print(bool(None))#False
print(bool(' '))#False
print(bool(""))#False
print(bool([]))#空列表
print(bool(list()))#空列表
print(bool(()))#空元组
print(bool(tuple()))#空元组
print(bool({}))#空字典
print((bool(dict())))#空字典
print(bool(set()))#空集合
print('--------其他对象的布尔值为True-------')
print(52)
print('helloworld')
- 选择结构 程序根据判断条件的布尔值选择性地执行部分代码 明确地让计算机知道在什么条件下，该去做什么
- 单分支结构 if 判断条件表达式==：==条件执行体1
money=1000#余额
s=int(input('请输入取款金额：'))#取款金额
#判断金额余额是否充足
if money>=s:
money-=s
print("取款成功，余额为：",money)
- 双分支结构 if条件表达式==：== 条件执行体1 else: 条件执行体2
#双分支结构if...else，二选一执行
'''从键盘录用一个整数，编写程序让计算机判断是奇数还是偶数'''
num=int(input('请输入一个整数'))
#条件判断
if num%2==0:
print(num,'是偶数')
else:
print(num,'是奇数')
- 多分支结构 if条件表达式==：== 条件执行体1 elif: 条件表达式==：== 条件执行体2…elif: 条件表达式==：== 条件执行体Nelse: 条件执行体N+1
'''多分支结构，多选一执行
从键盘录用一个整数 成绩
90-100 A
80-89 B
70-79 C
60-69 D
0-59 E
小于0或大于100 为非法数据（不是成绩的有限范围）
'''
score=float(input('请输入一个成绩：'))
#判断
if score>=90 and score<=100:
print('A级')
elif score>=80 and score<=89:
print('B级')
elif score>=70 and score<=79:
print('C级')
elif score>=60 and score<=69:
print('D级')
elif score>=0 and score<=59:
print('E级')
else:
print("对不起，成绩有误，不在成绩的有效范围")
另一种表达方式（更为简便）：
'''多分支结构，多选一执行
从键盘录用一个整数 成绩
90-100 A
80-89 B
70-79 C
60-69 D
0-59 E
小于0或大于100 为非法数据（不是成绩的有限范围）
'''
score=float(input('请输入一个成绩：'))
#判断
if 90<=score<=100:
print('A级')
elif 80<=score<=89:
print('B级')
elif 70<=score<=79:
print('C级')
elif 60<=score<=69:
print('D级')
elif 0<=score<=59:
print('E级')
else:
print("对不起，成绩有误，不在成绩的有效范围")
- 嵌套if if条件表达式1==：== if内层条件执行体1 else: 内层条件表达式2==：== 内层条件执行体2else: 条件执行体
'''
会员>=200 8折
>=100 9折
不打折
非会员 >=200 9.5折'
不打折
'''
answer=input('您是会员吗？y/n')
money=float(input('请输入您的购物金额：'))
#外层判断是否是会员
if answer=='y':
if money>=200:
print('打八折，付款金额为：',money*0.8)
elif money>=100:
print('打九折，付款金额为：',money*0.9)
else:
print('不打折，付款金额为：',money)
else: #非会员
if money >= 200:
print('打9.5折，付款金额为：', money * 0.95)
else:
print('不打折，付款金额为：', money)
- 条件表达式
- 条件表达式是if…else的简写
- 语法结构：x if判断条件else y
- 运算规则 如果判断条件的布尔值为True，条件表达式的返回值为x，否则条件表达式的返回值为False
'''从键盘录入两个整数，比较两个整数的大小'''
num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
#比较大小
'''if num_a>=num_b:
print(num_a,'大于等于',num_b)
else:
print(input(num_a,'小于',num_b))'''
print('使用条件表达式进入比较')
print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))
- pass语句
- 语句什么都不做，只是一个占位符，用在语法上需要语句的地方
- 什么时候使用：先搭建语法结构，还没想好代码怎么写的时候
- 哪些语句一起使用：
- if语句的条件执行体
- for-in语句的循环体
- 定义函数时的函数体
#pass语句，什么都不做，只是一个占位符，用到需要写语句的地方
answer=input('你是会员吗？y/n')
#判断是否是会员
if answer=='y':
pass
else:
pass
- range（）函数
- 用于生成一个整数序列
- 创建range对象三种方式
- range（stop) 创建一个（0，step）之间的整数序列，步长为1
- range（star，stop） 创建一个（start,stop)之间的整数序列，步长为1
- range（start，stop，step） 创建一个(start,stop)之间的整数序列，步长为step
- 返回值是一个迭代器对象
- range类型的优点：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start，stop和step,只有当用到range对象时，才会去计算序列中的相关元素
- in与not in 判断整数序列中是否存在（不存在）指定的整数
'''第一种创建方式，只有一个参数（小括号只给了一个数'''
r=range(10)#【0，1，2，3，4，5，6，7，8，9】，默认从0开始，默认相差1称为步长
print(r)#range（0，10）
print(list(r))#用于查看range对象中的整数序列 -->list是列表的意思
'''第二种创建方式，给了两个参数（小括号中给了两个数'''
r=range(1,10) #指定了起始值，从1开始，到10 结束（不包含10），默认步长为1
print(list(r))#[1,2,3,4,5,6,7,8,9]
'''第三种创建方式，给了第三个参数（小括号中给了三个数）'''
r=range(1,10,2)
print(list(r))#[1,3,5,7,9]
'''判断指定的整数，在序列中是否存在in,not in'''
print(10 in r)#False,10不在当前的r这个整数序列中
print(9 in r)#True，9在当前的r这个序列中
print(range(1,20,1)) #[1,...,19]
print(range(1,101,1))#[1,2,...,100]
- 反复做同一件事情的情况，称为循环
- 循环的分类：while/for-in
- while语法结构 while条件表达式：条件执行体（循环体）
- 选择结构的if与循环结构while的区别
- if是判断一次，条件为True执行一行
- while是判断N+1次，条件为True执行N次
a=1
#判断条件表达式
while a<10:
#执行条件执行体
print(a)
a+=1
- 四步循环法
- 初试化变量
- 条件判断
- 条件执行体（循环体）
- 改变变量
- while循环的执行过程
'''4步循环过程
- 初试化变量
- 条件判断
- 条件执行体（循环体）
- 改变变量
总结：初始化的变量与条件判断的变量与改变为同一个
'''
'''初始化变量为0'''
sum=0
a=0
'''条件判断'''
while a<5:
'''条件执行体（循环体）'''
sum+=a
'''改变变量'''
a+=1
print('和为',sum)
- for-in循环
- in表达从（字符串、序列等）中一次取值，又称为遍历
- for-in遍历的对象必须是可迭代对象
- for-in的语法结构
- for自定义的变量in可迭代对象：循环体
- 循环体内不需要访问自定义变量，可以将自定义变量替代为下划线
for item in 'python': #第一次取出来的是P，将P赋值值item，将item的值输出
print(item)
#range()产生一个整数序列，--》也是一个可迭代对象
for i in range(10):
print(i)
#如果在循环体重不需要使用到自定义变量，可将自定义变量写成"_"
for _ in range(5):
print('人生苦短，我用python')
sum=0
for item in range(1,101):
if item%2==0:
sum+=item
print("1到100之间的偶数和为",sum)
'''输出100到999之间的水仙花数
举例：153=3*3*3+5*5*5+1*1*1
'''
for item in range(100,1000):
ge=item%10
shi=item//10%10
bai=item//100
#判断
if ge*ge*ge+shi*shi*shi+bai*bai*bai==item:
print(item)
- break语句
- 用于结束循环结构，通常与分支结构if一起使用
'''从键盘录入密码，最多录入3次，如果正确就结束循环 '''
for item in range(3):
pwd=input('请输入密码：')
if pwd=='8888':
print('密码正确')
break
else:
print('密码不正确')
a=0;
while a<3:
'''条件执行体（循环体）'''
pwd=input('请输入密码')
if pwd=='8888':
print('密码正确')
break
else:
print('密码不正确')
#改变变量
a+=1
- continue语句
- 用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用
'''要求输出1到50之间所有5的背书，5，,10，,15，,20，,25....
5的倍数的共同点：和5的余数为0的数都是5的倍数
什么样不的数不是5的倍数，1，,2，,3，,4，,5，,6，,7，8，,9.。
。
。
'''
for item in range(1,51):
if item%5==0:
print(item)
print('------使用continue---------')
for item in range(1,51):
if item%5!=0:
continue
print
- else语句
-
与else语句配合使用的三种情况
- if…: …else:… if条件表达式不成立时执行else
- While…:…else:… 没有碰到break时执行else
- for…:…else:… 没有碰到break时执行else
for item in range(3):
pwd=input('请输入密码：')
if pwd=='8888':
print('密码正确')
break
else:
print('密码不正确')
else:
print('对不起，三次密码均不正确')
a=0
while a<3:
pwd=input('请输入密码')
if pwd=='8888':
print('密码正确')
break
else:
print('密码不正确')
#改变变量
a+=1
else:
print('对不起，三次密码均输入错误')
- 嵌套循环
-
循环结构中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行
'''输出一个三行四列的矩阵'''
for i in range(1,4):#行表，执行三次，一次是一行
for j in range(1,5):
print('*',end='\t') #不换行输出
print()#打行
for i in range(1,10):
for j in range(1,i+1):
print(i,'*',j,'=',i*j,end='\t')
print()
- 二重循环中的break和continue
-
二重循环中的break和continue用于控制本层循环
'''流程控制语句break与continue在二重循环中的使用 '''
for i in range(5):
for j in range(1,11):
if j%2==0:
#break #仅输出5个1
continue
print(j,end='\t')
print()
- 变量可以存储一个元素，而列表是一个“大容器”可以存储N多个元素，程序可以方便地对这些数据进行整体 *** 作
- 列表相当于其他语言中的数组
- 列表示意图
| 列表 | |||||||
|---|---|---|---|---|---|---|---|
| 索引 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
| 数据 | “hello” | “world” | 123 | 98.6 | “world” | 125 | “world” |
| 索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
- 列表需要使用中括号[].元素之间使用的英文的都好进行分隔
1st = [‘大圣’,’娟子姐]
列表名 赋值号 中括号
- 列表的创建方式
- 使用中括号
- 调用内置函数list（）
'''创建列表的第一种方式，使用[] '''
lst=['hello','world',98]
'''创建列表的第二种方式，使用内置函数list'''
lst2=list(['hello','world',98])
- 列表元素按顺序有序排序
- 索引映射唯一个数据
- 列表可以存储重复数据
- 任意数据类型混存
- 根据需要动态分配和回收内存
-
获取列表中制定元素的索引index()
- 如查询列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
- 如果查询的元素在列表中不存在，则会抛出ValueError
- 还可以制定的start和stop之间进行查找
-
获取列表中的单个元素
- 正向索引从0到N-1， 举例:lst[0]
- 逆向索引从-N都-1 举例：lst[-N]
- 指定索引不存，抛出indexError
lst=['hello','world',98,'hello'] print(lst.index('hello'))#如果列表中有相同的元素只返回列表中相同的第一个元素的索引 #print(lst.index('Python'))#ValueError: 'Python' is not in list #print(lst.index('hello',1,3))# ValueError: 'hello' is not in list print(lst.index('hello',1,4))
lst=['hello','world',98,'hello','love']
print(lst[1])#顺序获取索引为1的元素
print(lst[-1])#逆序获取索引为1的元素 ，范围-1到-N 此处输出为love
#获取索引为10
#print(lst[10])#IndexError: list index out of range
- 语法格式 列表名[start:stop:step]
- 切片 *** 作
- 切片的结果 原列表片段的拷贝
- 切片的范围 [start,stop]
- step默认为1 简写为[start,stop]
- step为正数
- [:stop:step] 切片的第一个元素默认是列表的第一个元素
- [start::step] 切片的最后一个元素默认是列表的最后一个元素
- 从start开始往后计算切片
- step为负数
- [:stop:step] 切片的第一个元素默认是列表的最后一个元素
- [start::step] 切片的最后一个元素默认是列表的第一个元素
- 从start开始往前计算切片
lst=[10,20,30,40,50,60,70,80]
#start=1,stop=6,step=1
#print(lst[1:6:1]) #[20, 30, 40, 50, 60]
'''原列表id 4367247040
切的片段id： 4368807424
'''
print('原列表id',id(lst))
lst2=lst[1:6:1]
print('切的片段id：',id(lst2))
print(lst[1:6])#默认步长为1
print(lst[1:6:])
#start=1,stop=6,step=2
print(lst[1:6:2])
#start默认,stop=6,step=2
print(lst[:6:2])
#start=1,stop默认,step=2
print(lst[1::2])
print("---------------step步长为负数的情况----------")
print('原列表',lst) #[10, 20, 30, 40, 50, 60, 70, 80]
print(lst[::-1]) #[80, 70, 60, 50, 40, 30, 20, 10]
#start=7，stop省略，step=-1
print(lst[6::-1]) #[70, 60, 50, 40, 30, 20, 10]
#start=6，stop=0,step=-2
print(lst[6:0:-2]) #[70, 50, 30]
-
判断指定元素在列表中是否存在
-
元素 in 列表名
元素 not in 列表名
-
列表元素的遍历
- for 迭代遍历 in 列表名： *** 作
print('p'in 'python')
print('k' not in 'python')
lst=[10,20,'python','hello']
print(10 in lst) #True
print(100 in lst)#False
print(10 not in lst)#False
print(100 not in lst)#True
print('-------------')
for item in lst:
print(item)
-
方法/其他 *** 作描述 增 append（） 在列表的末尾添加一个元素 加 extend（） 在列表的末尾至少添加一个元素 *** insert（） 在列表的任意位置添加一个元素 作 切片 在列表的任意位置添加至少一个元素
#向列表的末尾添加一个元素
lst=[10,20,30]
print('在添加元素之前',lst,id(lst))
lst.append(100)
print('添加元素之后',lst,id(lst))
lst2=['hello','world']
#lst.append(lst2) #将lst2作为一个元素添加到列表的末尾
#向列表的末尾一次性添加多个元素
lst.extend(lst2)
print(lst)
lst3=[True,False,'hello']
#在任意的位置上添加N多个元素
lst[1:]=lst3
print(lst)
-
方法/其他 *** 作描述 一次删除一个元素 remove() 重复元素只删除第一个 删 元素不存在抛出ValueError 除 *** 删除一个指定索引位置上的元素 作 Pop() 制定索引不存在抛出ValueError 不指定索引，删除列表中最后一个元素 切片 一次至少删除一个元素 clear() 清空列表 del 删除列表
lst=[10,20,30,40,50,60,30]#从列表中移除
lst.remove(30)
print(lst)
#lst.remove(100) #ValueError: list.remove(x): x not in list
#pop()根据索引移除元素
lst.pop(1)
print(lst) #[10, 40, 50, 60, 30]
#lst.pop(5) #IndexError: pop index out of range
lst.pop() #如果不指定参数（索引），将删除列表中的最后一个元素
print(lst)
print('-------------切片 *** 作-删除至少一个元素，将产生一个列表对象-------')
new_list=lst[1:3]
print('原列表',lst)
print('切片后的列表',new_list)
'''不产生新的列表对象，而是删除原列表中的内容 '''
lst[1:3]=[]
print(lst)
'''清除列表中的所有元素'''
lst.clear()
print(lst)
'''del语句将列表对象删除 '''
del lst
#print(lst) #NameError: name 'lst' is not defined.
- 为指定索引的元素赋予一个新值
- 为指定的切片赋予一个新值
lst=[10,20,30,40,50]
#一次修改一个值
lst[2]=52
print(lst)
#一次修改多个值
lst[1:3]=[232,123,521]
print(lst)
- 常见的两种方式
- 调用sort()方法，列中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序 排序
- 调用内置函数sorted(),可以指定reverse=True，进行降序 排序，原列表不发生改变
lst=[60,50,30,20,90,10]
print('排序前的列表',lst,id(lst))
#开始排序，调用列表对象的sort方法，升序排序
lst.sort()
print('排序后的列表',lst,id(lst))
'''
排序前的列表 [60, 50, 30, 20, 90, 10] 4374767296
排序后的列表 [10, 20, 30, 50, 60, 90] 4374767296
'''
#通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)#reverse=True 表示降序排序，reverse=False就是升序排序
print(lst)
#[90, 60, 50, 30, 20, 10]
lst.sort(reverse=False)#reverse=True 表示降序排序，reverse=False就是升序排序
print(lst)
print("----------使用内置函数sorted()对列表进行排序，将产生一个新的列表对象-------")
lst=[20,30,10,98,53]
print('原列表',lst)
#开始排序
new_list=sorted(lst)
print(lst)
print(new_list)
#指定关键字参数，实现列表元素降序排列
desc_list=sorted(lst,reverse=True)
print(desc_list)
- 列表生成式简称“生成列表的公式”
- 语法格式：[i*i for i in range(1,10)] 表示列表元素的表达式 for 自定义变量 in 可迭代对象
- 注意事项：“表示列表元素的表达式”中通常包含自定义变量
lst=[i for i in range(1,10)] #[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst)
lst=[i*i for i in range(1,10)] #[1, 4, 9, 16, 25, 36, 49, 64, 81]
print(lst)
'''列表中的元素的值为2，4，6,8，10...'''
lst2=[i*2 for i in range(1,6)]#[2, 4, 6, 8, 10]
print(lst2)
-
字典
- python内置的数据结构之一，与列表一样是一个可变序列，str字符串是不可变序列
- 以键值对的方式存储数据，字典是一个无序的序列
- 格式：scores={‘张三’：100，‘李四’：98，‘王五’:52} 字典名 = 花括号 键：值 , 键：值 花括号
-
字典示意图
| hash(key3) | Hash(key2) | hash(key1) | hash(key5) | |||||
| Key3 | key2 | key1 | Key5 | |||||
| v | v | v | v | |||||
| Value3 | Value2 | value1 | Value5 |
-
字典的实现原理
- 字典的实现原理与查字典类似，查字典是先根据部首或拼音查找对应的页码，python中的字典是根据key查找value所在的位置
-
字典的创建
- 最常用的方式：使用花括号scores={‘张三’：100，‘李四’：98，‘王五’:52}
- 使用内置函数dict（） dict(name=‘jack’,age=20)
#字典的创建方式
'''使用{}创建字典'''
scores={'张三':100,'李四':98,'王五':52}
print(scores)
print(type(scores))
'''第二种创建dict()'''
student=dict(name='jack',age=20)
print(student)
'''空字典'''
di=dict()
print(di)
- 字典中元素的获取
- [ ] 举例：scores[‘张三’]
- get()方法： 举例：scores.get(‘张三’)
- []取值与使用get()取值的区别
- []如果字典中不存在指定的key，抛出keyError异常
- get()方法取值，如果字典中不存在指定的key，并不会抛出keyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回
#获取字典的元素
scores={'张三':100,'李四':98,'王五':52}
'''第一种方式，使用[]'''
print(scores['张三']) #100
#print(scores['小明'])#KeyError: '小明'
'''第二章方式，使用get（）方法'''
print(scores.get('张三'))
print(scores.get('小明'))#None
print(scores.get('麻瓜',66))#66是在查找'麻瓜'所对的value
- key的判断
- In 指定的key在字典中存在返回True ‘张三’ in scores
- In 指定的key在字典中不存在返回True ‘Marry’ not in scores
- 字典元素的删除 del scores[‘张三’]
- 字典元素的新增 score[‘jack’]=90
#key的判断
scores={'张三':100,'李四':98,'王五':52}
print(scores)
print('张三' in scores)
print('张三' not in scores)
del scores['张三']#删除指定的key-value对
#score.clear() #清空字典的元素
print(scores)
scores['陈六']=98
print(scores)
scores['陈六']=100
print(scores)
- 获取字典视图的三个方法
- Keys() 获取字典中所有key
- values() 获取字典中所有value
- items() 获取字典中所有key，value对
scores={'张三':100,'李四':98,'王五':52}
#获取所有的key
keys=scores.keys()
print(keys)
print(type(keys))#- 字典元素的遍历
- 语法格式： for item in scores: print(item)
scores={'张三':100,'李四':98,'王五':52}
#字典元素的遍历
for item in scores:
print(item,scores[item],scores.get(item))
- 字典的特点
- 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
- 字典中的元素是无序的
- 字典中的key必须是不可变对象
- 字典也可以根据需要动态地伸缩
- 字典会浪费较大的内存，是一种使用空间换时间的数据结构
d={'name':'张三','name':'李四'} #key不允许重复
print(d) #{'name': '李四'}
d={'name':'张三','nikename':'张三'}
print(d) #{'name': '张三', 'nikename': '张三'}
lst=[10,20,30]
lst.insert(1,100)
print(lst) # [10, 100, 20, 30]
d={lst:100}#lst是可变的序列，不允许，必须为不可变对象，TypeError: unhashable type: 'list'
print(d)#TypeError: unhashable type: 'list'
- 字典生成式
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）