旭玖学Python

旭玖的Python学习笔记，佛系更新！

过去的辉煌只能代表过去，而不能代表现在和将来，需要让自己时刻保持着一种归零的状态，不骄不躁，不懂就问，不会就学。终有一日会让人惊叹不已。

一.变量与类型

(1).输出到文件原理讲解

print("您正在使用Python写入文件")sr=open('H:/ text.txt' , 'a+')          #sr:变量名 #open：打开某文件 #a+不存在文件就创建，存在文件就在文件中继续追加
print("欢迎使用Python写入文件" , file=sr)  #file=：写入到某变量下
print('你好啊'+'陌生人' , file=sr)
sr.close()                              #sr.close() 组成要素：变量+,close() 含义：关闭打开的文件

(2).变量的组成

标识:id

类型:type

值:value

(3).转义字符与原字符

1.转义字符

print("apple\nphone")   # \n 换行 光标移动到下一行print("apple\rphone")   # \r 回车 光标移动到本行的开头print("apple\tphone")   # \t tab 光标移动到下一组四个空格的开始处print("apple\bphone")   # \b backspace 回退一个字符

特殊意义的转义字符

# 在字符串中有特殊意义的转义字符# print("300\200")   # 错误
print("300\\200")    # 当需要使用反斜杠时，需要再次添加一个# print('晓东说:'真不错啊\')   # 错误
print('晓东说:\'真不错啊\'')   # 当输出内使用单引号的同时时，文本内也需要单引号时，需要在输出内的文本的第一个单引号前与后一个单引号前都添加反斜杠# print("胡佳说:"今天我请客"")  # 错误
print("胡佳说:\"今天我请客\"")  # 当输出内使用双引号的同时时，文本内也需要双引号时，需要在输出内的文本的第一个双引号前与后一个双引号前都添加反斜杠

2.原字符

# Python原字符
# 添加原字符（R或r）后，字符串内的转义字符将会失效，原字符需要添加在字符串"前print("今天是个好日子\n适合去打篮球")    # 使用Python原字符前
print(r"今天是个好日子\n适合去打篮球")   # 使用Python原字符后
print(R"今天是个好日子\n适合去打篮球")   # 使用Python原字符后

注意事项

# 注意事项:字符串内的最后一个字符不能为反斜杠，如需有反斜杠，再次添加一个反斜杠即可解决
# print(R"今天是个好日子\n适合去打篮球\")   #错误
print(R"今天是个好日子\n适合去打篮球\\")    #有反斜杠，再次添加一个反斜杠即可解决
print(r"今天是个好日子\n适合去打篮球\\")    #有反斜杠，再次添加一个反斜杠即可解决

(4).二进制

print(chr(0b100111001011000))   # 二进制
print(ord('乘'))                 # 十进制

乘
20056

输出二进制字符串时，需要添加0b

(5).标识符和保留字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存失败,源站可能有防盗链机制,建议将图片保存下来直接上传下上传(iMr34Z5oR0mn-1649820175565)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image211130517829647.png29)(C:%5CUsers%5Clll%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20211130212829647.png#pic_center)]

import keyword
print(keyword.kwlist)

['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', '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']

(6).数据类型

常见的数据类型

m1 = 8848
m2 = "hello world"
m3 = 3.14
m4 = Trueprint(m1, type(m1))
print(m2, type(m2))
print(m3, type(m3))
print(m4, type(m4))

8848 <class 'int'>
hello world <class 'str'>
3.14 <class 'float'>
True <class 'bool'>

1.整数类型

整数类型（int） →666

可表示 正数 负数 零

不同进制的表示方法不同

十进制：默认进制

二进制：0b开头

八进制：0o开头

十六进制：0x开头

print("十进制", 8848)
print("二进制", 0b01110111)
print("八进制", 0o6666)
print("十六进制", 0x6ACF)

十进制 8848
二进制 119
八进制 3510
十六进制 27343

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sflRBD4M-1655649820177)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211101105013903.png)]

2.浮点数类型

浮点数类型（float） →66.66

浮点数由整数和小数部分组成

​ 浮点数存在存储不精确性

​ 使用浮点数计算时存在小数位不精确的情况

​ 解决方案：导入decimal模块

m1 = 3.1415926
m2 = 1.1
m3 = 2.2
m4 = 2.1print(m1, type(m1))
print(m2 + m3)                  # 个别差异
# 输出的值为：3.3000000000000003
print(m2 + m4)                  # 正常
# 输出的值为：3.2# 解决个别差异
# 导入模块decimal
from decimal import Decimal
print(Decimal("1.1") + Decimal("2.2"))
# 输出的值为：3.3

3.1415926 <class 'float'>
3.3000000000000003
3.2
3.3

3.布尔类型

布尔类型（bool） →false，true

布尔类型用来表示真和假

True表示真，False表示假

布尔值可以转化为整数

​ - True = 1

​ - False = 0

m1 = True
m2 = False
print(m1, type(m1))
print(m2, type(m2))print(m1 + 0)
print(m2 + 0)

True <class 'bool'>
False <class 'bool'>
1
0

4.字符串类型

字符串类型（str） →人生苦短，我用Python

字符串被称为不可变的字符序列

可以使用单引号，双引号，三引号来定义

单引号和双引号定义的字符串必须在同一行

三引号定义的字符串可以分布在连续的多行

m1 = "人生苦短，我用Python"
m2 = '人生苦短，我用Python'
m3 = """人生苦短，我用Python"""
m4 = '''人生苦短，我用Python'''print(m1, type(m1))
print(m2,type(m2))
print(m3,type(m3))
print(m4,type(m4))

人生苦短，我用Python <class 'str'>
人生苦短，我用Python <class 'str'>
人生苦短，我用Python <class 'str'>
人生苦短，我用Python <class 'str'>

(7).类型转化

1.字符串类型无法被整数类型和浮点数类型转化
2.整数类型转化浮点数时会省略小数点后的字符
3.浮点数类型转化除字符串外都会在字符后添加小数点及小数后一位

4.转化类型时需在数据前加上相应的函数名

数据类型转换的函数名

整数类型 int()
字符串类型 str()
浮点数类型 float()

转化类型时需在数据前加上相应的函数名

a1 = 666666
a2 = 66.66
a3 = '人生苦短，我学Python'
a4 = Trueprint('''
# 数据类型转换的函数名
int()           # 整数类型
str()           # 字符串类型
float()         # 浮点数类型
''')print('--------------整数类型的转化--------------')print(int(a1), type(a1), type(int(a1)))
# 666666 <class 'int'> <class 'int'>print(int(a2), type(a2), type(int(a2)))     # 浮点类型转化整数类型会省略小数点后的值
# 66 <class 'float'> <class 'int'># print(int(a3), type(a3), type(int(a3)))   # 字符串类型无法转化为整数类型print(int(a4), type(a4), type(int(a4)))
# 1 <class 'bool'> <class 'int'>print('--------------字符串类型的转化--------------')print(str(a1), type(a1), type(str(a1)))
# 666666 <class 'int'> <class 'str'>print(str(a2), type(a2), type(str(a2)))
# 66.66 <class 'float'> <class 'str'>print(str(a3), type(a3), type(str(a3)))
# 人生苦短，我学Python <class 'str'> <class 'str'>print(str(a4), type(a4), type(str(a4)))
# True <class 'bool'> <class 'str'>print('--------------浮点数类型的转化--------------')print(float(a1), type(a1), type(float(a1)))
# 666666.0 <class 'int'> <class 'float'>print(float(a2), type(a2), type(float(a2)))
# 66.66 <class 'float'> <class 'float'># print(float(a3), type(a3), type(float(a3)))       # 字符串类型无法转化为浮点数类型print(float(a4), type(a4), type(float(a4)))
# 1.0 <class 'bool'> <class 'float'>print('-----------总结---------')
print('''字符串类型无法被整数类型和浮点数类型转化，
整数类型转化浮点数时会省略小数点后的字符，
浮点数类型转化除字符串外都会在字符后添加小数点及小数后一位''')

# 数据类型转换的函数名
int()           # 整数类型
str()           # 字符串类型
float()         # 浮点数类型--------------整数类型的转化--------------
666666 <class 'int'> <class 'int'>
66 <class 'float'> <class 'int'>
1 <class 'bool'> <class 'int'>
--------------字符串类型的转化--------------
666666 <class 'int'> <class 'str'>
66.66 <class 'float'> <class 'str'>
人生苦短，我学Python <class 'str'> <class 'str'>
True <class 'bool'> <class 'str'>
--------------浮点数类型的转化--------------
666666.0 <class 'int'> <class 'float'>
66.66 <class 'float'> <class 'float'>
1.0 <class 'bool'> <class 'float'>
-----------总结---------
字符串类型无法被整数类型和浮点数类型转化，
整数类型转化浮点数时会省略小数点后的字符，
浮点数类型转化除字符串外都会在字符后添加小数点及小数后一位进程已结束，退出代码为 0

各类型之间可互相转化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Faqxomi-1655649820178)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211104202213091.png)]

总结

1.字符串类型无法被整数类型和浮点数类型转化
2.整数类型转化浮点数时会省略小数点后的字符
3.浮点数类型转化除字符串外都会在字符后添加小数点及小数后一位

知识点总结

二.运算符

(1).输入函数input

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QZHT31lU-1655649820179)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211104204649130.png)]

# 信息采集器
name = input('请输入姓名:')
age = int(input('请输入年龄:'))
telephone_number = int(input('请输入手机号码:'))
print('输入完成!')
print('------'+name+'的信息''------')
print('姓名:', name)
print('年龄:', age)
print('手机号码:', telephone_number)
print('请核对您的信息!')

请输入姓名:法外狂徒张三
请输入年龄:26
请输入手机号码:09948339666
输入完成!
------法外狂徒张三的信息------
姓名: 法外狂徒张三
年龄: 26
手机号码: 9948339666
请核对您的信息!

(2).运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gmEfuzY1-1655649820179)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211104212323965.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mBaTN6cK-1655649820180)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211104212348371.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-td91RgIk-1655649820180)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211104212418404.png)]

print(6 + 6)        # 加法运算
print(6 - 5)        # 减法运算
print(6 * 6)        # 乘法运算
print(6 / 2)        # 除法运算
print(9 // 2)       # 整除运算
print(-9 // -2)     # 整除运算
print(9 // -2)      # 整除运算 一负一正向下取整
print(-9 // 2)      # 整除运算 一负一正向下取整
print(9 % 2)        # 取余运算
print(9 % -4)       # 取余运算
# 一正一负要公式 余数=被除数-除数*商 9-（-4）* -3 =-3print(6 ** 2)       # 幂运算

12
1
36
3.0
4
4
-5
-5
1
-3
36

整除运算 一负一正向下取整

取余运算 一正一负需要公式:余数=被除数-除数*商

(3).赋值运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UpCQDxPZ-1655649820180)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211107211209108.png)]

print('------赋值运算符------')
# 运算顺序从右向左
x = 66 + 99
print(x)
print('------链式赋值------')
a = b = c = 20
# id 是标识
print(a, id(a))
print(b, id(b))
print(c, id(c))
print('------参数赋值------')
a = 0
print(a, type(a))
a += 10
print(a, type(a))
a -= 5
print(a, type(a))
a *= 10
print(a, type(a))
a /= 3
print(a, type(a))
a //= 2
print(a, type(a))
a %= 5
print(a, type(a))
a **= 3
print(a, type(a))print('------系列解包赋值------')
a, b, c = 20, 40, 60
print(a, b, c)print('------交换两个变量的值------')
a, b = 30, 20
print('交换前', a, b)
a, b = b, a
print('交换后', a, b)

------赋值运算符------
165
------链式赋值------
20 2194895235984
20 2194895235984
20 2194895235984
------参数赋值------
0 <class 'int'>
10 <class 'int'>
5 <class 'int'>
50 <class 'int'>
16.666666666666668 <class 'float'>
8.0 <class 'float'>
3.0 <class 'float'>
27.0 <class 'float'>
------系列解包赋值------
20 40 60
------交换两个变量的值------
交换前 30 20
交换后 20 30

(4).比较运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KBAMOhj6-1655649820181)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211109231841512.png)]

总结：

1.一个=叫赋值运算符两个==叫比较运算符

2.两个==比较的是 值 value

3.is，is not比较的是 标识 id

print("------------------------------------")
a, b = 30, 20
print('a大于b吗？', a > b)
print('a小于b吗？', a < b)
print('a等于b吗？', a == b)
print('a小于等于b吗？', a <= b)
print('a大于等于b吗？', a >= b)
print('a不等于b吗？', a != b)
print('划重点：一个=叫赋值运算符，两个==叫比较运算符')
print('两个==比较的是 值 value')print("------------------------------------")a = 20
b = 50
print('a和b的id一样吗？', a is b)                 # a与b的标识是否相等
print('a和b的iD不一样？', a is not b)             # a与b的标识是否不相等
print('划重点： is，is not比较的是 标识 id')print("------------------------------------")sy1 = [44, 55, 66]
sy2 = [44, 55, 69]
print('sy1和sy2的值value是否相等:', sy1 == sy2)           # 比较值value的大小
print("输出sy1的标识id:", id(sy1))
print("输出sy2的标识id:", id(sy2))
print('sy1和sy2的标识id是否相同:', sy1 is sy2)           # 比较标识id是否相同
print('sy1和sy2的标识id是否不相同:', sy1 is not sy2)       # 比较标识id是否不同

------------------------------------
a大于b吗？ True
a小于b吗？ False
a等于b吗？ False
a小于等于b吗？ False
a大于等于b吗？ True
a不等于b吗？ True
划重点：一个=叫赋值运算符，两个==叫比较运算符
两个==比较的是 值 value
------------------------------------
a和b的id一样吗？ False
a和b的iD不一样？ True
划重点： is，is not比较的是 标识 id
------------------------------------
sy1和sy2的值value是否相等: False
输出sy1的标识id: 2275688262336
输出sy2的标识id: 2275687051712
sy1和sy2的标识id是否相同: False
sy1和sy2的标识id是否不相同: True

(5).布尔运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IzrQhgt3-1655649820182)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211109233856619.png)]

总结：

  1. [and] 当两个运算符都为True时，运算结果为True，反之为False

  2. [or]当有一个运算符为True时，运算结果为True，反之为False

  3. [not]取反向运算结果，当运算数为True时运算结果为False，当运算数为False时运算结果为True

  4. [in]查看变量中是否含有某值

  5. [not in]查看变量中是否不存在某值

a, b = 6, 9print('--------- and 并且 -----------')print(a == 6 and b == 9)
print(a == 6 and b < 9)
print(a == 6 and b > 9)
print(a < 6 and b == 9)
print(a > 6 and b == 9)
print(a != 6 and b == 9)
print(a == 6 and b != 9)print('--------- or 或者 -----------')
print(a == 6 or b == 9)
print(a == 6 or b < 9)
print(a == 6 or b > 9)
print(a < 6 or b == 9)
print(a > 6 or b == 9)
print(a != 6 or b == 9)
print(a == 6 or b != 9)print('--------- not 对bool类型操作数取反 -----------')
edg = True
dk = False
print(not edg)
print(not dk)print('--------- in与not in -----------')
lol = 'EDG是冠军，DK是垃圾'
print('EDG' in lol)
print('DK是垃圾' not in lol)

--------- and 并且 -----------
True
False
False
False
False
False
False
--------- or 或者 -----------
True
True
True
True
True
True
True
--------- not 对bool类型操作数取反 -----------
False
True
--------- in与not in -----------
True
False

(6).位运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cf00IjjF-1655649820182)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211113211048521.png)]

print(8 & 1)    # 按位与&，二进制下同为1时结果为1
print(8 | 2)    # 按位或|，二进制下同为0时结果为0

0
10

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5XUFgHVg-1655649820182)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211113211932290.png)]

print(8 << 1)   # 向左移动一个位置（1位） 相当于乘以2
print(8 << 2)   # 向左移动两个位置（2位） 相当于乘以4
print(8 << 1)   # 向右移动一个位置（1位） 相当于除以2
print(8 << 2)   # 向右移动两个位置（2位） 相当于除以4

16
32
16
32

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h6j6EQ4G-1655649820183)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211113212807070.png)]

(7).运算符的优先级

！！！重点！！！

运算符的计算原理：

括号()–>算数运算–>位运算–>比较运算–>布尔运算–>赋值运算

括号优先级最高

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VKyFpirM-1655649820183)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211114205945174.png)]

(8).小总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Isfw9Gu-1655649820184)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211114210430664.png)]

三.分支结构

程序的三种结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tc0x0BiF-1655649820192)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211116201545081.png)]

(1).程序的组织结构—顺序结构

# 顺序结构
print('------大象装进冰箱------')
print('1.打开冰箱门')
print('2.把大象放进冰箱')
print('3.关上冰箱门')
print('------装箱完成------')

------大象装进冰箱------
1.打开冰箱门
2.把大象放进冰箱
3.关上冰箱门
------装箱完成------

(2).对象的布尔值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dQhaEpU5-1655649820192)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211116203137969.png)]

# 测试对象的布尔值
print('---------以下的对象布尔值均为False-------------')
print(bool(False))      # 布尔类型的False
print(bool(0))          # 整数的零（0）
print(bool(0.0))        # 浮点数的0.0
print(bool(None))       # 特殊的空值（一个空对象）
print(bool(''))         # 空的字符串
print(bool(""))         # 空的字符串
print(bool([]))         # 空列表
print(bool(list()))     # 空列表
print(bool(()))         # 空元组
print(bool(tuple()))    # 空元组
print(bool({}))         # 空字典
print(bool(dict()))     # 空字典
print(bool(set()))      # 空集合print('-----------以下及剩下的皆为True--------------')
print(bool(True))       # 布尔类型True
print(bool(666))        # 整数类型
print(bool(66.66))      # 浮点数类型
print(bool('中华有为，国之荣耀'))    # 字符串类型
print('...等')

---------以下的对象布尔值均为False-------------
False
False
False
False
False
False
False
False
False
False
False
False
False
-----------以下及剩下的皆为True--------------
True
True
True
True
...等

(3).分支结构—单分支结构

if是条件表达式一

money = 6000
m = int(input('请输入取款金额:'))
if money >= m:print('取款成功，剩余金额为:', money - m)

请输入取款金额:5999
取款成功，剩余金额为: 1请输入取款金额:665
取款成功，剩余金额为: 5335

完整版

money = 6000
m = int(input('请输入取款金额:'))
if money >= m:print('取款成功，剩余金额为:', money - m)
else:print('余额不足，可用余额为:', money)

请输入取款金额:5600
取款成功，剩余金额为: 400请输入取款金额:66666
余额不足，可用余额为: 6000

(4).分支结构—双分支结构

if是条件表达式一

else是条件表达式二

print是条件执行体

# 判断输入的数是奇数还是偶数
number = int(input("请输入待判断的数字:"))
if number % 2 == 0:print('输入的数为偶数')
else:print('输入的数为奇数')

请输入待判断的数字:0
输入的数为偶数请输入待判断的数字:66
输入的数为偶数请输入待判断的数字:75
输入的数为奇数

(5).分支结构—多分支结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y7ge0Aux-1655649820193)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211119231205584.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sWy5P1xk-1655649820193)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211119231220806.png)]

# 成绩等级评定
cj = int(input("请输入你的成绩:"))if cj >= 100 and cj <= 90:print('成绩为A')
elif cj >= 80 and cj <= 89:print('成绩为B')
elif cj >= 70 and cj <= 79:print('成绩为C')
elif cj >= 60 and cj <= 69:print('成绩为D')
elif cj >= 50 and cj <= 59:print('成绩为E')
elif cj >=  0 and cj <= 49:print('你成绩不及格，重新补考吧')
else:print('成绩有误，请重新输入')

(6).分支结构—嵌套if的使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wB1BxxLI-1655649820193)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211119231427562.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iJleqeRl-1655649820194)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211119231437816.png)]

'''目标：
设置会员优惠机制会员
满200打8折
满100打9折
不满100不打折非会员
满200打9.5折
不满不打折'''hy = input('您有无会员？')
vip = '无'
if hy == 'you':vip = '有'
elif hy == '有':vip = '有'
else:vip = '无'
xf = float(input('您的购物金额？'))
hy = vip
if hy == vip:print('您'+hy+'会员')if xf >= 200:print('您应付:', xf * 0.8, '\b元')elif xf >= 100:print('您应付:', xf * 0.9, '\b元')else:print('您应付', xf, '\b元')else:print('您'+hy+'会员')if xf >= 200:print('您应付:', xf * 0.95, '\b元')else:print('您应付:', xf, '\b元')
print('欢迎您的下次光临！')

您有无会员？wu
您的购物金额？3223
您无会员
您应付: 2578.4元
欢迎您的下次光临！

您有无会员？you
您的购物金额？4546
您有会员
您应付: 3636.8元
欢迎您的下次光临！

(7).条件表达式

'''程序设计：输入两个数，进行比较'''
pf1 = float(input('请输入第一个数:'))
pf2 = float(input('请输入第二个数:'))
# 使用条件表达式进行比较
print(str(pf1)+'大于'+str(pf2) if pf1 > pf2 else str(pf1)+'小于'+str(pf2))

请输入第一个数:45
请输入第二个数:5454
45.0小于5454.0

请输入第一个数:45454
请输入第二个数:4555
45454.0大于4555.0

使用条件表达式进行比较时，需先写print，然后在print内输入if、alse，在if前填写if条件成立的条件执行体，在else后填写if条件不成立的条件执行体

(8).pass语句

可替换程序执行语句

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sJFzAsUw-1655649820194)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211120214254445.png)]

vip = input('您是否为本店的VIP,'+'yes/no')if vip == 'yes':pass
else:pass

您是否为本店的VIP,yes/noyes

知识点总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-psBjdjMy-1655649820195)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211120214234592.png)]

四.循环

(1).range函数的使用

笔记： range 函数的三种创建方式

  1. list 是列表的意思，print(list(a))的意思是输出列表内的数# range 函数的三种创建方式

  2. list 是列表的意思，print(list(a))的意思是输出列表内的数

  3. range内仅仅储存start（开始值）、stop（结束值）和step（间隔值）

  4. start（斯达特）stop（斯到普）step（斯丹普）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zn5HwBvF-1655649820195)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211122201911867.png)]

# range 函数的三种创建方式
# list 是列表的意思，print(list(a))的意思是输出列表内的数
# range内仅仅储存start（开始值）、stop（结束值）和step（间隔值）
# start（斯达特）stop（斯到普）step（斯丹普）
'''第一种创建方式,只含一个参数（小括号中只有一个数）'''
print('----------第一种----------')
a = range(15)
# 仅包含stop值，默认从0开始
print(a)            # range(0, 15)
print(list(a))      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]'''第二种创建方式，包含两个参数（小括号内包含两个数）'''
print('----------第二种----------')
b = range(1, 15)
# 包含了start（开始值）和stop（结束值）
print(b)            # range(1, 15)
print(list(b))      # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]'''第三种创建方式，包含三个参数（小括号内包含三个数）'''
print('----------第三种----------')
c = range(1, 21, 2)
# 包含了start（开始值）、stop（结束值）和step（间隔值）
print(c)            # range(1, 21, 2)
print(list(c))      # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

----------第一种----------
range(0, 15)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
----------第二种----------
range(1, 15)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
----------第三种----------
range(1, 21, 2)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

(2).while循环结构

笔记：

四部循环法：
1.初始化变量
2.条件判断
3.条件执行体（循环体）
4.改变变量
总结：初始化的变量和条件改变的变量与改变的变量是同一个

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ttalPxE-1655649820195)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211122205935185.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wvrw80kG-1655649820196)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211122210242219.png)]

'''while循环语法结构'''
print('while循环语法结构')
a = 1               # 变量
while a <= 5:       # 条件判断print(a)        # 输出变量a += 1          # 改变变量'''while循环四部循环法'''
'''
四部循环法：
1.初始化变量
2.条件判断
3.条件执行体（循环体）
4.改变变量
总结：初始化的变量和条件改变的变量与改变的变量是同一个'''
print('四部循环法')
sum = 0             # 用于存储累加变量
b = 0               # 初始化变量为0
while b <= 5:       # 条件判断b += 1          # 改变变量sum += b        # 条件执行体
print('输出的和为:', sum)            # 输出累加变量值

while循环语法结构
1
2
3
4
5
四部循环法
输出的和为: 21

(2.1).while循环结构练习

# 输出1-100之间的偶数和
# 初始化变量
a = 1
number1 = 0
# 条件判断
while a <= 100:if a % 2 == 0:number1 += aa += 1
print('1-100之间的偶数和为:', number1)
# 输出1-100之间的奇数和
# 初始化变量
b = 1
number2 = 0
# 条件判断
while b <= 100:if b % 2 != 0:number2 += bb += 1
print('1-100之间的奇数和为:', number2)

1-100之间的偶数和为: 2550
1-100之间的奇数和为: 2500

改进后的代码

# 输出1-100之间的偶数和# 初始化变量
a = 1
b = 1
number1 = 0
number2 = 0
# 条件判断
while a <= 100:if not bool(a % 2):number1 += aa += 1
print('1-100之间的偶数和为:', number1)
while b <= 100:if bool(b % 2):number2 += bb += 1
print('1-100之间的奇数和为:', number2)

(3).for_in循环结构

笔记：

两步循环法:

  1. for (自定义一个变量，也可用_(下划线)代替) in (可迭代对象)：
  2. 输入循环体

**注意：**in后可从字符串或者序列（range）中取值，也称作遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GSPeRw3d-1655649820199)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211126212030432.png)]

for item in 'Python':           # item为自定义变量print(item)                 # 一行一行输出Python的每一个字母# range是整数序列，也是一个可迭代对象
for ioc in range(6):            # ioc为自定义变量print(ioc)                  # 一行一行输出整数序列for _ in range(20):             # 使用下划线（_）可代替自定义变量print('小龙人是龙不是人')

P
y
t
h
o
n
0
1
2
3
4
5
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人
小龙人是龙不是人

(3.1)for_in循环结构练习

求百位内的水仙花数

**注:**水仙花数也称为超完全数字不变数、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数，水仙花数是指一个三位数，它的每个位上的数字的三次幂之和等于它本身。

例如:13+53+3^3=153

'''
输出100-999的水仙花数
举例：
153=3*3*3+5*5*5+1*1*1
'''
print('----开始计算100-999之间的水仙花数-----')
for sxh in range(100, 999):ge = sxh % 10                       # 求出水仙花数的个位shi = sxh // 10 % 10                # 求出水仙花数的十位bai = sxh // 100                    # 求出水仙花数的百位if bai**3+shi**3+ge**3 == sxh:      # 条件判断:百位的三次方加十位的三次方加个位的三次方是否在水仙花数的变量中print(sxh)                      # 输出满足上述条件的水仙花数
print('-----计算完成-----')

----开始计算100-999之间的水仙花数-----
153
370
371
407
-----计算完成-----

(4).break流程控制语句

for_in版

a = 3
for password in range(3):password = int(input('请输入密码:'))if password == 8888:print('密码正确')breakelse:a = a - 1print('密码错误,请重新输入,还剩%d次机会' % a)

请输入密码:5545454
密码错误,请重新输入,还剩2次机会
请输入密码:45454
密码错误,请重新输入,还剩1次机会
请输入密码:54545
密码错误,请重新输入,还剩0次机会

请输入密码:8888
密码正确

while版

a = 3                                       # 初始化变量a（可输入密码的次数）
while a > 0:                                # 条件判断password = int(input('请输入密码:'))      # 条件执行体if password == 666666:                  # 分支结构print('密码输入正确')break                               # 流程结束控制语句else:a = a - 1if a > 0:print("请重新输入密码,还剩%d次机会！" % a)else:print('密码错误,请稍后重试！')

请输入密码:14
请重新输入密码,还剩2次机会！
请输入密码:4
请重新输入密码,还剩1次机会！
请输入密码:4
密码错误,请稍后重试！

请输入密码:666666
密码输入正确

(5).continue流程控制语句

continue是结束不符合的循环，进入下一循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kxexoKJQ-1655649820200)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211130203819649.png)]

'''输出100以内5的倍数'''
for item in range(1, 101):if item % 5 != 0:continueprint(item)

5
10
15
20
25
30
35
40
45
50
55
60
65
70
75
80
85
90
95
100

(6).else语句

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55xSegZK-1655649820200)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211130203846930.png)]

'''密码验证'''for password in range(3):password = input("请输入密码:")if int(password) == 666666:print("密码输入正确")breakprint("密码错误，请重新输入:")
else:print("密码连续三次错误，请稍后重试！")

请输入密码:666666
密码输入正确

请输入密码:545445
密码错误，请重新输入:
请输入密码:54545
密码错误，请重新输入:
请输入密码:5454
密码错误，请重新输入:
密码连续三次错误，请稍后重试！

(7).嵌套循环

# 输出九九乘法表
for a in range(1, 10):for b in range(1, a+1):print(a, '*', b, '=', a * b, end="\t")print()

1 * 1 = 1
2 * 1 = 2  2 * 2 = 4
3 * 1 = 3  3 * 2 = 6  3 * 3 = 9
4 * 1 = 4  4 * 2 = 8  4 * 3 = 12 4 * 4 = 16
5 * 1 = 5  5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6  6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7  7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8  8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9  9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81

(8).二重循环中的break和continue

for a in range(3):for b in range(1, 10):if b % 2 == 0:continue  # 跳出本次循环# break    跳出当前循环print(b, end='\t')print()

1    3   5   7   9
1   3   5   7   9
1   3   5   7   9

知识点总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TOXTRggS-1655649820200)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211130210707220.png)]

五.列表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F8xeru7q-1655649820201)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211202204427615.png)]

(1).为什么需要列表[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JAVq45b0-1655649820201)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211202204356414.png)]

列表展示

a = 'Hello'
b = "World"
c = "我是Python"
lit = [a, b, c]
print(lit)                  # 输出列表

['Hello', 'World', '我是Python']

(2).创建列表

创建列表

第一种方式，使用[] 第二种方式，使用内置函数list()

以下代码中的ufo和ufc皆为列表对象

列表对象内存储的是对象的引用

# 创建列表的第一种方式，使用[]
a = 66
b = 77
c = 88
ufo = [a, b, c]             # ufo是列表对象 []里的值是元素
print(ufo)
# 创建列表的第二种方式，使用内置函数list()
ufc = list([a, b, c])       # ufc存储的是对象的引用
print(ufc)

[66, 77, 88]
[66, 77, 88]

(3).列表的特点

1.列表元素按顺序有序排列
2.索引映射唯一数据
3.列表可以存储重复数据
4.任意数据类型混存
5.根据需要动态分配和回收内存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-krV58yk4-1655649820201)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211202210819812.png)]

'''
列表元素按顺序有序排列
索引映射唯一数据
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存
'''
a = 561
b = 3.14
c = '终端'
d = True
ask = [a, b, c, d]          # # 任意数据类型混存
print(ask)                  # 列表元素按顺序有序排列
print(ask[0])               # 索引映射唯一数据
print(ask[3])               # 索引映射唯一数据

[561, 3.14, '终端', True]
561
True

(4).元素与索引

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t0cAWgP0-1655649820202)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211203205024743.png)]

1.获取指定元素的索引

注意:

1.当列表内有两个相同的元素时，只输出第一个元素的索引

2.当列表内没有此元素时，文件就会报错

3.当列表内查不到该序列，文件就会报错

abc = ['word', 'excel', 'ppt', 'word', 98]
print(list(abc))
print(abc.index('word'))                    # 当列表内有两个相同的元素时，只输出第一个元素的索引
print(abc.index('ppt'))
# print(abc.index('python'))                当列表内没有此元素时，文件就会报错
print(abc.index('word', 0, 5))                # 在0到5里获取该索引
# print(abc.index('ppt', 0, 2))             当列表内查不到该序列，文件就会报错

['word', 'excel', 'ppt', 'word', 98]
0
2
0

2.获取列表中指定的元素

**注意:**当索引不存在时，文件会报错

abc = ['python', '海绵宝宝', 'man', 2021, 3.14]
print(abc)
print(abc[1])           # 正向索引
print(abc[-2])          # 逆向索引
# print(abc[45])          # 索引不存在，文件报错   IndexError

['python', '海绵宝宝', 'man', 2021, 3.14]
海绵宝宝
2021

3.获取列表中的多个元素—切片操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xORgDHvE-1655649820202)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211203210609828.png)]

adc = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(adc[0:9:1])                       # 从第一个索引0开始，到最后一个索引9结束，中间步长为1
# start(开始)=0   stop(结束)=9  step(步长)=1
print(adc[:9:1])                        # 默认start是第一个元素0
# start=0       stop=9      step=1
print(adc[1::1])                        # 默认stop是最后一个元素9
# start=1       stop=9      step=1
print(adc[1:9:])                        # 默认step是1
# start=1       stop=9      step=1
print('--------------步长为负数--------------')
print('原列表\n'+str(adc))
print(adc[::-1])                        # 默认start是最后一个元素    默认stop是第一个元素
print(adc[9:0:-1])

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 4, 5, 6, 7, 8, 9]
--------------步长为负数--------------
原列表
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[10, 9, 8, 7, 6, 5, 4, 3, 2]

4.列表元素的判断和遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3OS93wLc-1655649820202)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211204202417944.png)]

print('----------列表元素的判断----------')
jw3 = [66, 99, 'python', 'EDG', 'HUAWEI', 'Kin98k']
print('python' in jw3)
print('Kin98k' not in jw3)
print('----------列表元素的遍历----------')
for jw in jw3:print(jw)

----------列表元素的判断----------
True
False
----------列表元素的遍历----------
66
99
python
EDG
HUAWEI
Kin98k

5.列表元素的添加操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pd5AvfrC-1655649820203)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211204203507520.png)]

phone = ['play', 'x', 'magic', 'number']
print('初始列表:')
print(phone)print('append之后的列表')
huawei = ['nova']
phone.append(huawei)                            # 在列表末尾添加一个元素   （只能添加一个）
print(phone)print('extend之后的列表')
huawei1 = ['mate', 'P']
phone.extend(huawei1)                           # 在列表末尾至少添加一个元素   （可以添加多个）
print(phone)print('insert之后的列表')
huawei2 = ['畅享']
phone.insert(4, huawei2)                        # 在列表的任意位置添加一个元素    （只能添加一个）
print(phone)print('切片之后的列表')
huawei3 = ['畅享', 'nova', 'mate', 'P', '麦芒']
phone[4:] = huawei3                             # 在列表的任意位置添加至少一个元素  （可以添加多个，会覆盖start之后的元素）
print(phone)

初始列表:
['play', 'x', 'magic', 'number']
append之后的列表
['play', 'x', 'magic', 'number', ['nova']]
extend之后的列表
['play', 'x', 'magic', 'number', ['nova'], 'mate', 'P']
insert之后的列表
['play', 'x', 'magic', 'number', ['畅享'], ['nova'], 'mate', 'P']
切片之后的列表
['play', 'x', 'magic', 'number', '畅享', 'nova', 'mate', 'P', '麦芒']

6.列表元素的删除操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Shv3a6Cm-1655649820203)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211204210925579.png)]

adc = [10, 20, 30, 40, 50, 60, 70, 80, 20, 30]
print('----------remove删除元素----------')
adc.remove(20)                      # 重复元素只删除第一个
adc.remove(80)                      # 只能删除一个元素
# adc.remove(300)                   # 元素不存在时报错
print(adc)print('----------pop删除指定索引元素----------')
adc.pop(6)                          # 删除指定位置上的元素
adc.pop()                           # 不指定时删除列表最后一个元素
# adc.pop(10)                       # 索引不存在时报错
print(adc)print('----------切片操作，至少删除一个元素，将产生一个新的列表对象----------')
new_adc = adc[0:3]
print('原列表', adc)
print('新列表', new_adc)print('----------clear清空列表----------')
adc.clear()                         # 清空列表
print(adc)print('----------del删除列表----------')
del adc                             # 删除列表
# print(adc)                        # 列表被删除

----------remove删除元素----------
[10, 30, 40, 50, 60, 70, 20, 30]
----------pop删除指定索引元素----------
[10, 30, 40, 50, 60, 70]
----------切片操作，至少删除一个元素，将产生一个新的列表对象----------
原列表 [10, 30, 40, 50, 60, 70]
新列表 [10, 30, 40]
----------clear清空列表----------
[]
----------del删除列表----------

7.列表元素的修改操作

xyh = ['秀儿', 666, '戏精', 99, '屌丝']
print(xyh)
xyh[2] = '沙雕'                                          # 指定索引修改一个值
print(xyh)
xyh[3:4] = ['猛男粉爱好者', '小米发烧友']                   # 指定索引段修改多个值
print(xyh)
xyh[3:4] = ['猛男粉爱好者', '小米发烧友', '烟民', '修仙者']   # 指定索引段修改多个值
print(xyh)

['秀儿', 666, '戏精', 99, '屌丝']
['秀儿', 666, '沙雕', 99, '屌丝']
['秀儿', 666, '沙雕', '猛男粉爱好者', '小米发烧友', '屌丝']
['秀儿', 666, '沙雕', '猛男粉爱好者', '小米发烧友', '烟民', '修仙者', '小米发烧友', '屌丝']

8.元素的排序操作

.sort() 排序操作

.sort(reverse=False) 排序操作-降序

.sort(reverse=True) 排序操作-升序

ppt = [95, 54, 65, 87, 56, 98, 21, 13, 30]
print("排序前的列表", ppt)
print('开始排序')
ppt.sort()              # 默认升序
print('默认升序', ppt)ppt1 = [95, 54, 65, 87, 56, 98, 21, 13, 30]
print('排序前的列表', ppt1)
print('开始排序')
ppt1.sort(reverse=True)
print('降序', ppt1)
ppt1.sort(reverse=False)
print('升序', ppt1)

排序前的列表 [95, 54, 65, 87, 56, 98, 21, 13, 30]
开始排序
默认升序 [13, 21, 30, 54, 56, 65, 87, 95, 98]
排序前的列表 [95, 54, 65, 87, 56, 98, 21, 13, 30]
开始排序
降序 [98, 95, 87, 65, 56, 54, 30, 21, 13]
升序 [13, 21, 30, 54, 56, 65, 87, 95, 98]

9.列表生成式

psk = [i*i for i in range(1, 5)]
print(psk)# 生成列表元素为2,4,6,8,10
book = [a*2 for a in range(1, 6)]
print(book)

[1, 4, 9, 16]
[2, 4, 6, 8, 10]

知识点总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HrGY79rv-1655649820203)(C:\Users\lll\AppData\Roaming\Typora\typora-user-images\image-20211207211915178.png)]

# -*- coding: utf-8 -*-"""
@author: 旭玖
@software: PyCharm
@file: 列表巩固.py
@time: 2021/12/18 0018 下午 12:53
"""
bbg = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]           # 创建列表对象
print('---------------关于列表元素的简单操作------------------')
print(bbg[0])                                   # 输出列表对象内第一个索引的元素
print(bbg[-1])                                  # 输出列表对象内的倒数第一个元素
print(bbg.index(6))                             # 输出列表对象内元素6的索引
print(bbg.index(1, 0, 5))                       # 在元素0-5之间查找元素6的索引并输出
print(bbg[0:9:1])                               # 输出列表对象内索引从0到9的元素，间隔值为1
print(bbg[9:0:-1])                              # 输出列表对象内索引从9到0的元素，间隔值为-1，逆向输出
print('99' in bbg)                              # 判断99是否存在于列表对象bbg中，存在为True，不存在为False
print('6' in bbg)                               # 判断6是都存在于对象bbg中，存在为True，不存在为False
for bgg in bbg:                                 # 元素遍历print(bgg)                                  # 输出遍历的元素对象bgg
print('---------------列表对象增加元素操作------------------')
bbg.append(15)                                  # 在元素对象末尾添加一个元素
print(bbg)
x1 = 16, 17, 18
bbg.extend(x1)                                  # 在元素对象末尾添加一个或多个元素
print(bbg)
print(bbg.index(15))                            # 查询元素15位于该列表对象的索引
bbg.insert(10, 11)                              # 在列表对象内索引为10的后面添加一个元素
print(bbg)
x2 = 12, 13, 14
print(bbg.index(11))                            # 查询列表对象内元素11的索引
bbg[10:] = x2                                   # 在该列表内索引为10的后面添加x2并覆盖x2之后的元素
print(bbg)
print('---------------列表对象删除元素操作------------------')
bbg.insert(0, 1)                                # 在列表对象内索引0之后添加一个元素1
print(bbg)
bbg.remove(1)                                   # 删除列表对象内的元素1（重复的只删除第一个）
print(bbg)
bbg.remove(14)                                  # 删除列表对象内的元素14
print(bbg)
print(bbg.index(13))                            # 查询列表对象内元素13的索引
bbg.pop(11)                                     # 删除列表对象内索引为13的元素hgg = [0]                                       # 创建一个新列表hgg
hgg.extend(bbg)                                 # 利用extend复制bbg列表
print(hgg)                                      # 输出创建的列表hggbbg.clear()                                     # 清空bbg列表内的元素
print(bbg)del bbg                                         # 删除列表bbg
print('---------------列表对象修改元素操作------------------')
print(hgg.index(12))                            # 查询列表内12的索引
hgg[11] = 13                                    # 修改索引11的元素为13
print(hgg)
hgg[10:11] = [28, 21, 26, 23]                   # 修改索引10到11的元素为28, 21, 26, 23
print(hgg)
print('---------------列表对象元素排序操作------------------')
hgg.sort()                                      # 对列表对象hgg进行排序，默认升序
print(hgg)
hgg.sort(reverse=True)                          # 对列表对象hgg进行降序排序
print(hgg)
hgg.sort(reverse=False)                         # 对列表对象hgg进行升序排序
print(hgg)
print('---------------列表生成式------------------')
ljr = [i * i for i in range(1, 6)]              # 定义变量ljr为range整数序列1-6（不包括6）中的平方数
print(ljr)
lxy = [a * a for a in range(9, 20)]              # 定义变量lxy为range整数序列9-20（不包括20）中的平方数
print(lxy)

---------------关于列表元素的简单操作------------------
1
10
5
0
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, 9, 8, 7, 6, 5, 4, 3, 2]
False
False
1
2
3
4
5
6
7
8
9
10
---------------列表对象增加元素操作------------------
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 18]
10
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 15, 16, 17, 18]
10
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14]
---------------列表对象删除元素操作------------------
[1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13]
11
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12]
[]
---------------列表对象修改元素操作------------------
11
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 28, 21, 26, 23, 13]
---------------列表对象元素排序操作------------------
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 21, 23, 26, 28]
[28, 26, 23, 21, 13, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 21, 23, 26, 28]
---------------列表生成式------------------
[1, 4, 9, 16, 25]
[81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]

Python学习笔记（旭玖）相关推荐

  1. [python教程入门学习]python学习笔记（CMD执行文件并传入参数）

    本文章向大家介绍python学习笔记(CMD执行文件并传入参数),主要包括python学习笔记(CMD执行文件并传入参数)使用实例.应用技巧.基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋 ...

  2. python学习笔记之编写readConfig读写配置文件

    python学习笔记之编写readConfig读写配置文件_weixin_34055910的博客-CSDN博客

  3. Python学习笔记（十一）

    Python学习笔记(十一): 生成器,迭代器回顾 模块 作业-计算器 1. 生成器,迭代器回顾 1. 列表生成式:[x for x in range(10)] 2. 生成器 (generator o ...

  4. Python学习笔记一简介及安装配置

    Python学习笔记一 参考教程:廖雪峰官网https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e54 ...

  5. python学习笔记目录

    人生苦短,我学python学习笔记目录: week1 python入门week2 python基础week3 python进阶week4 python模块week5 python高阶week6 数据结 ...

  6. Python学习笔记（二）：标准流与重定向

    Python学习笔记(二):标准流与重定向 - SamWei - 博客园 Python学习笔记(二):标准流与重定向 Posted on 2012-02-19 22:36 SamWei 阅读(176) ...

  7. python 学习笔记 12 -- 写一个脚本获取城市天气信息

    近期在玩树莓派,前面写过一篇在树莓派上使用1602液晶显示屏,那么可以显示后最重要的就是显示什么的问题了. 最easy想到的就是显示时间啊,CPU利用率啊.IP地址之类的.那么我认为呢,假设可以显示当 ...

  8. python基本语法语句-python学习笔记：基本语法

    原标题:python学习笔记:基本语法 缩进:必须使用4个空格来表示每级缩进,支持Tab字符 if语句,经常与else, elif(相当于else if) 配合使用. for语句,迭代器,依次处理迭代 ...

  9. 廖Python学习笔记一

    1. 廖Python学习笔记 大的分类 如函数 用二级标题,下面的用三级 如输入输出 1.1.1. 输入输出 1.1.1.1. 输出 用 print() 在括号里加上字符串,就可以向屏幕上输出指定的文 ...

最新文章

  1. 提高代码改造过程的小想法
  2. python中的路径问题汇总
  3. npm包全局安装和局部安装,执行包命令有什么不同？
  4. object.assign
  5. Java的native方法-----你必须要知道的JAVA知识
  6. 分布式SESSION一致性
  7. yml读取环境变量_读取yml配置文件中的值
  8. windows xp下Apache2.2.11整合Tomcat6.0.20
  9. 使用Asp.net的TreeView来构建用户选择输入
  10. 【Google Play】创建 Google 开发者账号 ( 注册邮箱账号 | 创建开发者账号 )
  11. html table自动序号,layui 给数据表格加序号的方法
  12. 手机浏览器下载文件名乱码解决
  13. python查看虚拟环境列表_python虚拟环境virtualenv高级篇
  14. 硬件_1bit为什么等于6db
  15. 职称计算机ppt,2017年职称计算机考试（PPT练习题大全）(3)
  16. 3Dmax基础：游戏建模渲染小技巧
  17. B站弹幕姬()分析与开发（上篇）
  18. C/C++编程：写了placement new也要写placement delete
  19. 大白话教你认识 Kafka 背后优秀的架构设计
  20. CSMACD协议与CSMACA协议

热门文章

  1. VMOS+小黄鸟解决抓包小程序无网络问题2（附工具）
  2. 李开复：关于如何打造领导力，我的九点思考
  3. android开发游记：仿支付宝余额数字累加滚动效果的实现
  4. 使用火狐浏览器下载文件需要等很长时间的解决办法
  5. 刷了一天回溯算法 2022年6月16日
  6. 苏州源特VPS8702/S 微功率隔离电源专用芯片 3-6VIN/0.5A 功率管
  7. Sass-@if,@else if的用法
  8. oracle左右外连接,Oracle中左右外连接详解
  9. 在windwos模拟器运行lvgl--LVGL-windwos环境搭建
  10. Android深色主题背景的实现及主题背景颜色互换