Python基础学习（一）

最新推荐文章于 2024-05-06 00:08:33 发布

三笠·阿卡曼

最新推荐文章于 2024-05-06 00:08:33 发布

阅读量1.2k

点赞数 25

文章标签： python 学习开发语言

本文链接：https://blog.csdn.net/cjl_xupt/article/details/135513952

版权

Python基础语法学习记录

输出

将结果或内容呈现给用户

print("休对故人思故国，且将新火试新茶，诗酒趁年华")
# 输出不换行，并且可以指定以什么字符结尾
print("青山依旧在",end= ",")
print("几度夕阳红",end= "。")

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.数据类型

2.1 整型(int)

print(222)
print(2 ** 2)  # 2的2次方
print(10 / 2)

2.2 字符串(str)

# 单引号和双引号一样
print("Hello World")
print("上海市浦东新区")
print("我是'艾伦'")
# """表示多行字符串
print("""
人生到处何所似,
应是飞鸿踏雪泥。
"""
)

对于字符串：

拼接: +
乘：整型和字符串进行相乘，实现字符串重复出现N次并拼接

print(3 * "我想吃拉面")

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.3 布尔类型(bool)

bool类型种共有两个值：True/False

print(1 > 2)
print(False)
print(True)
print(1 == 1)

name = input("请输入你的用户名: ")
if name.lower() == "zed":
    print(name + "登录成功")
else:
    print("登录失败")

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

补充：

1 == ‘Alan’ # 可以比较

1 > ‘Alan’ # 不可以进行比较

2.4 数据类型转换

不同的数据类型有不同的功能，如果想要做转换，可遵循一个原则，想转换什么类型就让它包裹住

如：str(666)是将整型转化为字符串，int(“888”)是将字符串转为整型

类型转换

其他所有类型转为布尔类型时，除了空字符串、0以外其他都是True；
字符串转为整型时，只有是数字类型的字符串（“669”）才可转换为整型，其他都报错；
想要转换为哪种类型，就用这个类型的英文包裹一下就可以

str(…)

int(…)

bool(…)

3.变量

注意：

给变量赋值；
让age代指某个值；

name = "Zed"
age = 24
flag = 1 > 2
print(name)
print(age)
print(flag)

3.1 变量名的规范

三个规范：

变量名由字母、数字、下划线组成；
不能以数字开头；
不能用Python内置的关键字；

变量内存指向

情景一

name = "sushi"

在计算机的内存中创建一块区域保存字符串”sushi”，name变量名则指向这块区域。

情景二

name = "sushi"
name = "alex"

在计算机的内存中创建一块区域保存字符串”sushi”，name变量名则指向这块区域。然后又再内存中创建了一块域保存字符串”alex”，name变量名则指向”alex”所在的区域，不再指向”sushi”所在区域（无人指向的数据会被标记为垃圾，由解释器自动化回收）

情景三

name = "sushi"
new_name = name

在计算机的内存中创建一块区域保存字符串”sushi”，name变量名则指向这块区域。new_name变量名指向name变量，因为被指向的是变量名，所以自动会转指向到name变量代表的内存区域。

情景四

name = "sushi"
new_name = name
name = "alex"

在计算机的内存中创建一块区域保存字符串”sushi”，name变量名则指向这块区域(灰色线)，然后new_name指向name所指向的内存区域，最后又创建了一块区域存放”alex”，让name变量指向”alex”所在区域.

情景五

num = 18
age = str(num)

在计算机的内存中创建一块区域保存整型18，name变量名则指向这块区域。通过类型转换依据整型18再在内存中创建一个字符串”18”, age变量指向保存这个字符串的内存区域。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

4.注释

单行注释

# 声明一个name变量
name = 'Alan'

多行注释

"""
这是一个多行注释
这是一个多行注释
这是一个多行注释
这是一个多行注释
"""

5.输入

实现用户与程序之间的交互

# 接收用户输入的变量
name = input("请输入用户名: ")

特别注意:

用户输入的任何内容都是字符串；

6.条件语句

if 条件:
    ...
else:
    ...

6.1 基本条件语句

示例1

username = "sushi"
password = "666"
if username == "sushi" and password == "666":
	print("恭喜你，登录成功")
else:
	print("登录失败")

示例2

username = "sushi"

if username == "sushi" or username == "alex":
	print("VIP大会员用户")
else:
	print("普通用户")

示例3

number = 19
if number%2 == 1:
	print("number是奇数")
else:
	print("number是偶数")

number = 19
data = number%2 == 1
if data:
	print("number是奇数")
else:
	print("number是偶数")

示例4

if 条件:
  成立

print("开始")
if 5 == 5:
  print("5等于5")
print("结束")

6.2 多条件判断

if 条件A:
  A成立，执行此缩进中的所有代码
  ...
elif 条件B:
  B成立，执行此缩进中的所有代码
  ...
elif 条件C:
  C成立，执行此缩进中的所有代码
  ...
else:
  上述ABC都不成立。

6.3 条件嵌套

if 条件A:
    if 条件A1:
        ...
    else：
   	    ...
elif 条件B:
    ...

模拟10086客服

print("欢迎致电10086，我们提供了如下服务： 1.话费相关；2.业务办理；3.人工服务")

choice = input("请选择服务序号")

if choice == "1":
    print("话费相关业务")
    cost = input("查询话费请按1;交话费请按2")
    if cost == "1":
        print("查询话费余额为100")
    elif cost == "2":
        print("交互费")
    else:
        print("输入错误")
elif choice == "2":
    print("业务办理")
elif choice == "3":
    print("人工服务")
else:
    print("序号输入错误")

7. 循环语句

while循环

while 条件:
	...
	...
	...

for循环

7.1 循环语句基本使用

num = 1
while num < 4:
    print("2024发大财")
    num += 1

7.2 break 终止循环

break，用于while循环中终止循环；

7.3 continue结束本次循环

continue, 在循环中用于结束本次循环，开始下一次循环；

7.4 while else

当while后的条件不成立时，else中的代码就会执行

while 条件:
    代码
else:
    代码

num = 1
while num < 5:
    print("2024一夜暴富")
    num += 1
else:
    print("2024一定会发财")

8. 字符串格式化

8.1 %格式化

# 引入
name = "苏东坡"
age = 18
text = "我叫%s，今年%d岁" %(name,age)

message = "%(name)s你什么时候过来呀？%(user)s今天不在呀。" % {"name": "死鬼", "user": "李杰"}
print(message)

8.1.2 百分比特殊处理

text = "%s，这个片我已经下载了90%%了，居然特么的断网了" %"兄弟"
print(text)
# 输出：
兄弟，这个片我已经下载了90%了，居然特么的断网了

8.2 format格式化（推荐）

text1 = "我叫{0}, 今年{1}岁".format("Alan",19)
text2 = "我叫{0}, 今年{1}岁,真实姓名是{0}".format("Alan",19)
print(text1)
print(text2)
################################
text = "我叫{n1}，今年18岁".format(n1="Alan")
text = "我叫{n1}，今年{age}岁".format(n1="Alan",age=18)
text = "我叫{n1}，今年{age}岁，真是的姓名是{n1}。".format(n1="Alan",age=18)
################################
# 先定义格式化字符串，再调用format方法传递参数
text = "我叫{0}，今年{1}岁"
data1 = text.format("Alan",666)
data2 = text.format("alex",73)
address = "{0}市{1}区{2}街道"
print(address.format("上海","浦东新","溜溜"))

8.3 f格式化（Python3.6之后）

hobby1 = "打游戏"
hobby2 = "打球"
message = f"我喜欢{hobby1},还喜欢{hobby2}"
###
输出: 我喜欢打游戏,还喜欢打球  
###

9. 运算符

9.1 算数运算符

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

9.2 比较运算符

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

9.3 赋值运算

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

9.4 成员运算

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

9.5 逻辑运算

10. Python数据类型

常见数据类型：

int，整数类型
bool，布尔类型
str，字符串；
list，列表类型；
tuple，元组类型；
dict，字典类型；
set，集合类型；
float，浮点型；

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

10.1 整型

10.1 定义

number = 10
age = 99

10.2 独有功能

无

v1 = 5
print(bin(v1))  # 0b101
# 调用v1（int）的独有功能，获取v1的二进制有多少个位组成。
result1 = v1.bit_length()
print(result1)  # 3

v2 = 10
print(bin(10))  # 0b1010
# 调用v2（int）的独有功能，获取v2的二进制有多少个位组成。
result2 = v2.bit_length()
print(result2)  # 4

10.3 公共功能

加减乘除

v1 = 4
v2 = 8
v3 = v1 + v2

10.4 转换

在项目开发和面试题中经常会出现一些 “字符串” 和布尔值转换为整型的情况。

# 布尔值转整型
n1 = int(True)  # True转换为整数 1
n2 = int(False) # False转换为整数 0

# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制)
v3 = int("0o144",base=8)  # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制)
v4 = int("0x59",base=16)  # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）

# 浮点型（小数）
v1 = int(8.7) # 8

所以，如果以后别人给你一个按二进制、八进制、十进制、十六进制规则存储的字符串时，可以轻松的通过int转换为十进制的整数。

10.5 其他

10.5.1 长整型

Python3：整型（无限制）
Python2：整型、长整形

在python2中跟整数相关的数据类型有两种：int(整型)、long（长整型），他们都是整数只不过能表示的值范围不同。

int，可表示的范围：-9223372036854775808～9223372036854775807
long，整数值超出int范围之后自动会转换为long类型（无限制）。

在python3中去除了long只剩下：int（整型），并且 int 长度不在限制。

10.5.2 地板除

Py3：
```
v1 = 9/2 
print(v1) # 4.5
```

py2:

v1 = 9/2 
print(v1) # 4

from __future__ import division 

v1 = 9/2 
print(v1) # 4.5

10.2 布尔型

10.3 字符串

"xxxx".方法名(参数)

s = "xxx"
s.方法名(...)

10.3.1 判断字符串是否以XX为开头startswith

# 案例
s.startswith("北京市")

10.3.2 判断字符串是否以XX结尾endswith

s.endswith("大厦")

10.3.3 判断字符串是否是整数

message.isdecimal()

10.3.4 判断字符串是否为十进制数

v1 = "123"
print(v1.isdecimal()) # True

v2 = "①"
print(v2.isdecimal()) # False

v3 = "123"
print(v3.isdigit()) # True

v4 = "①"
print(v4.isdigit()) # True

10.3.5 去除字符串两边的空格、换行符、制表符，得到一个新字符串

msg = " H e ll o啊，树哥 "
data = msg.strip()
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥"

msg = " H e ll o啊，树哥 "
data = msg.lstrip()
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥 "

msg = " H e ll o啊，树哥 "
data = msg.lstrip()
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥 "

案例：

# 案例
code = input("请输入4位验证码：") #  FB88   fb88 
value = code.upper() #  FB88  
data = value.strip() # FB88

if data == "FB87":
	print('验证码正确')
else:
	print("验证码错误")
  
# 注意事项
"""
code的值"fb88 "
value的值"FB88 "
data的值"FB88"
"""

去除两边指定的内容：

msg = "哥H e ll o啊，树哥"
data = msg.strip("哥")
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树"

10.3.5 字符串变大写

msg = "my name is the flash"
data = msg.upper()
print(data) # MY NAME IS THE FLASH

10.3.6 字符串变小写

msg = "MY NAME IS THE FLASH"
data = msg.lower()
print(data) # my name is the flash

10.3.7 字符串的替换

data = "你是个好人，但是好人不合适我"
value = data.replace("好人","贱人")
print(data)  # "你是个好人，但是好人不合适我"
print(value) # "你是个贱人，但是贱人不合适我"

# 案例
video_file_name = "喜剧片.mp4"
new_file_name = video_file_name.replace("mp4","avi") # "喜剧片.avi"
final_file_name = new_file_name.replace("喜剧","科幻") # "科幻片.avi"
print(final_file_name)

10.3.8 字符串的切割

data = "Alan|root|alan@qq.com"
result = data.split('|') # ["Alan","root","alan@qq.com"]
result2 = data.split('|', 1) # 切一个，遇到第一个切
result3 = data.rsplit('@') #
print(data) # "Alan|root|alan@qq.com"
print(result) # 输出 ["Alan","root","alan@qq.com"] 根据特定字符切开之后保存在列表中，方便以后的操作

10.3.9 字符串的拼接

data_list = ["Alan", "", "a", "huge","man"]
new_str = " ".join(data_list) # Alan is a huge man
print(new_str)

10.3.10 格式化字符串

address = "{0}市{1}区{2}街道"
data = address.format("上海","浦东新", "潍坊")
print(data) #上海市浦东新区潍坊街道

10.3.11 字符串转为字节类型

data = "苏东坡"  # unicode，字符串类型

v1 = data.encode("utf-8")  # utf-8，字节类型
v2 = data.encode("gbk")  # gbk，字节类型

print(v1)  # b'\xe8\x8b\x8f\xe4\xb8\x9c\xe5\x9d\xa1'
print(v2)  # b'\xcb\xd5\xb6\xab\xc6\xc2'

s1 = v1.decode("utf-8") # 苏东坡
s2 = v2.decode("gbk") # 苏东坡
print(s1)
print(s2)

10.3.12 字符串内容居中、居左、居右显示

v1 = "王老汉"
# data = v1.center(21, "-")
# print(data) #---------王老汉---------

# data = v1.ljust(21, "-")
# print(data) # 王老汉------------------

# data = v1.rjust(21, "-")
# print(data) # ------------------王老汉

10.3.13 给字符串填充0

data = "alex"
v1 = data.zfill(10)
print(v1) # 000000alex
# 应用场景：处理二进制数据
data = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"

10.3.14 公共功能

1、相加，字符串拼接

2、相乘，字符串 * 整数

3、长度

data = "zed"
print(len(data)) # 3

4、获取字符串中的字符，索引

message = "北京欢迎你"
print(message[0]) # 北
print(message[1]) # 京
print(message[2]) # 欢

字符串中是能通过索引取值，无法修改值；

5、获取字符串中的子序列，切片

message = "就像阳光穿破黑夜"
print(message[0:2]) # 就像
print(message[2:]) # 阳光穿破黑夜
print(message[:2]) # 就像

print(message[6:-1]) # 黑
print(message[6:len(message)]) # 黑夜

字符串切片自己读取数据，无法修改数据

6、步长，跳着取字符串的内容

name = "生活不是电影，生活比电影苦"

print( name[ 0:5:2 ] )   # 输出：生不电 【前两个值表示区间范围，最有一个值表示步长】
print( name[ :8:2 ] )    # 输出：生不电，  【区间范围的前面不写则表示起始范围为0开始】、
# print( name[ 2::2 ] )    # 输出：不电，活电苦
# print( name[ 2::3 ] )    # 输出：不影活影

print( name[ 2::3 ] )    # 输出：不电，活电苦 【区间范围的后面不写则表示结束范围为最后】
print( name[ ::2 ] )     # 输出：生不电，活电苦 【区间范围不写表示整个字符串】
print( name[ 8:1:-1 ] )  # 输出：活生，影电是不 【倒序】

7、循环

while循环

message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
index = 0
while index < len(message):
	print(message[index])
	index += 1

for循环

message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
for char in message:
    print(char)

range：帮助创建一系列数字

range(10) # [0,1,2,3,4,5,6,7,8,9]
range(1, 10) # [1,2,3,4,5,6,7,8,9]
range(1, 10, 2) #[1,3,5,7,9]
range(10, 1, -1) # [10,9,8,7,6,5,4,3,2]

for + range:

for i in range(10)
	print(i)
message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
for i in range(5):
    print(message[i])
####################
for i in range(len(message)):
    print(message[i])

10.3.15 字符串类型转换

num = 999
data = str(num)
print(data) # "999"

10.3.16 字符串不可被修改

name = "Alan"

11.4 列表(list)

列表(list)，是一个可变的容器，在里面可以存放多个不同类型的元素

11.4.1 定义

user_list = ["李白","苏轼","辛弃疾"]
number_list = [92,93,94,95]
data_list = [1,True,"Alan", "张楚岚"]

user_list = []
user_list.append("盖聂")
user_list.append(123)
user_list.append(False)
print(user_list) # ["盖聂",123,False]

不可变类型：字符串、布尔、整型

可变类型：列表

11.4.2 独有功能

1、追加，在原有列表中尾部追加值

data_list = []
data_list.append("s1")
data_list.append("s2")

2、批量追加，将一个列表中的元素逐一添加到另外一个列表

tools = ["板砖","菜刀"]
weapon = ["AK47","MP5"]
tools.extend(weapon)

print(tools)

3、插入，在原列表的指定索引位置插入值

user_list = ["李白","杜甫","白居易"]
user_list.insert(1,"王维") # ["李白","王维","杜甫","白居易"]

4、在原列表中根据值删除（从左到右找到第一个删除，慎用！里面没有会报错）

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
if "孙笑川" in user_list:
	user_list.remove("孙笑川")
print(user_list)

5、在原列表中根据索引删除某个元素（根据索引位置删除）

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.pop(1) # 删除索引为1的元素
user_list.pop() #删除最后一个元素 ["李白","辛弃疾"]

item = user_list.pop()

6、清空原列表

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.clear()
print(user_list) # []

7、根据值获取索引（从左到右找到第一个，慎用！找不到会报错）

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
if "孙笑川" in user_list:
	index = user_list.index("孙笑川")
print(index) # 3

8、列表元素排序

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.sort()
print(user_list) # 默认从小到大排序
print(user_list.sort(reverse=True)) # 从大到小排序
# 注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）

9、反转原列表

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.reverse()
print(user_list) # 列表会反转

11.4.3 公共功能

1、相加，两个列表相加获取生成一个新的列表

data_list1 = ["李白","杜甫"]
data_list2 = ["苏轼","辛弃疾"]

data_list3 = data_list1 + data_list2
print(data_list3) # ["李白","杜甫","苏轼","辛弃疾"]

2、相乘(列表*整型，将列表中的元素再创建N份并生成一个新的列表)

data_list = ["李白","杜甫"] * 2
print(data_list) # ["李白","杜甫","李白","杜甫"]

3、运算符in包含

由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中

user_list = ["李白","杜甫","苏轼","白居易"]
result1 = "白居易" in user_list
result2 = "辛弃疾" in user_list
print(result1) # True
print(result2) # False

4、获取长度

user_list = ["李白","杜甫","苏轼","白居易"]
print(len(user_list)) # 4

5、索引

user_list = ["李白","杜甫","苏轼","白居易"]
print(user_list[3]) # 白居易
del user_list[0] #删除第0个元素

6、切片

# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']

print( user_list[0:2] ) # ["范德彪","刘华强"]
print( user_list[1:] )
print( user_list[:-1] )

# 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[3:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四']

# 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']

7、步长

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
#              0        1        2          3       4
print( user_list[1:4:2] ) # 刘华强 宋小宝
print( user_list[0::2] ) # 
print( user_list[1::2] ) # 
print( user_list[4:1:-1] ) # 刘能 宋小宝 尼古拉斯赵四

# 案例：实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]
print(new_data)


data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()
print(data_list)

# 给你一个字符串请实现字符串的翻转？
name = "12345"
name[::-1]

8、for循环

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
	print(item)

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]

for index in range( len(user_list) ):
    item = user_index[index]
    print(item)

切记，循环的过程中对数据进行删除会踩坑

# 错误方式， 有坑，结果不是你想要的。

user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)
        
print(user_list)
# 正确方式，倒着删除。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
    item = user_list[index]
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)

11.4.4 转换

int、bool无法转换成列表
字符串转成列表没有意义；

name = "苏东坡"
list(name) # ["苏","东","坡"]

元组、集合转成list

v1 = (11,22,33,44)
vv1 = list(v1) # [11,22,33,44]

v2 = {"alex", "alan","otto"}
vv2 = list(v2) # ["alex", "alan", "otto"]

11.4.5 其他

嵌套

data = ["赵四",["1","2","3"],True, [11,22,[33,44]]]

11.5 元组(tuple)

列表（list）：是一个有序且可变的容器，在里面可以存放多个不同类型的元素；

元组（tuple）：是一个有序且不可变的容器，在里面可以存放多个不同类型的元素；

11.5.1 定义

v1 = (11,22,33)
v2 = ("小明","Alan")
v3 = (True,123,"Alex",[11,22,33])
# 建议：在元组的最后一个元素后面多加一个逗号，用来表示它是一个元组
v3 = ("Alan",11, )

11.5.5 公共功能

1、相加，两个列表相加获取一个新的元组

v1 = ("小明","小亮")
v2 = ("张三","李四")
v3 = v1 + v2
print(v3) # ("小明","小亮","张三","李四", )

2、相乘，列表*整型，将列表中的元素再创建N份

v1 = ("小明","小亮")
print(v1*2)

3、获取长度

user_tuple = ("小明","小亮","张三")
print(len(user_tuple)) # 3

4、索引

user_tuple = ("小明","小亮","张三")
print(user_tuple[1]) #小亮

5、切片

user_tuple = ("小明","小亮","张三")
print(user_tuple[0:2]) # 小明 销量

6、步长

user_tuple = ("小明","小亮","张三","李四","王五")
print(user_tuple[1:4:2])
print(user_tuple[4:1:-1])
# 反转tuple
new_user_tuple = user_tuple[::-1]
print(new_user_tuple)

7、for循环

user_tuple = ("小明","小亮","张三","李四","王五")
for item in user_tuple:
    print(item)

for item in user_tuple:
    if item == "张三":
        continue
    print(item)

目前，只有str、list、tuple可以被for循环

11.5.3 转换

其他类型转换为元组，使用tuple(其他类型)，目前只有字符串和列表可以转换为元组

data = tuple(其他)
# str/list

11.5.4 嵌套

由于元组和列表都可以充当容器，他们内部也可以放多个元组，并且也支持元素内的嵌套

12.6 set集合

set集合：无序、可变、不允许数据重复的容器

12.6.1 定义

v1 = {1,"22",True,"Alex"}

无序：无法通过索引定位值

可变：可以添加和删除元素

v1 = {11,22,33}
v1.add(44)
print(v1) # {11,22,33,44}

不允许数据重复

v1 = {11,22,33}
v1.add(11)
print(v1) # 11 22 33

什么时候用到集合：

想要维护一大堆不重复的数据的时候，就可以用它，比如：做爬虫去网上找图片链接时，为了避免数据重复，可以选择用集合去存储链接地址

注意：定义空集合时候，只能使用v=set{},不能使用v={}(这样定义是一个空字典)

12.6.2 独有功能

1、添加元素

data = {"苏东坡","白居易","辛弃疾"}
data.add("欧阳修")
print(data)

data = set()
data.add("周杰伦")
data.add("薛之谦")
print(data)

2、删除元素

data = {"苏东坡","白居易","辛弃疾","王富贵"}
data.discard("王富贵")
print(data)

3、交集

s1 = {"苏东坡","白居易","辛弃疾","王富贵"}
s2 = {"李白","杜甫","王勃","王富贵"}
s3 = s1 & s2 #取两个集合的交集
s4 = s1.intersection(s2) # 王富贵
print(s3,s4)

4、并集

s1 = {"苏东坡","白居易"}
s2 = {"李白","杜甫"}
s3 = s1 | s2
s4 = s1.union(s2)
print(s3,s4)

5、差集

s1 = {"刘能","赵四","皮常山"}
s2 = {"刘科长","赵市长","皮常山"}
s3 = s1 - s2 #取差集，s1中有且s2中没有的值
s3 = s1.difference(s2) #取差集，s1中有且s2中没有的值

12.6.3 公共功能

1、减，计算差集

2、&，取交集

3、|，计算并集

4、长度

v1 = {"张三","李四","王五"}
data = len(v1)
print(data)

5、for循环

v1 = {"张三","李四","王五"}
for item in v1:
    print(item)

12.6.4 转换

其他类型如果想转换成集合类型，使用set(其他类型)，如果数据有重复会自动删除

注意： int/list/tuple/dict都可以转换为集合

12.6.5 其他

12.6.5.1 集合的存储原理

12.6.5.2 元素必须可哈希

因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。

目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。

总结：集合的元素只能是 int、bool、str、tuple 。

转换成功

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}

转换失败

v1 = [11,22,["alex","eric"],33]
v2 = set(v1) # 报错 
print(v2)

12.6.5.3 查找速度特别快

user_set = {"苏东坡","alex","李璐"}
if "alex" in user_set:
    print("在")
else:
    print("不在")

12.6.5.4 对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	`v=[]或v=list()`
tuple	否	是	无	是	tuple(其他)	`v=()或v=tuple()`
set	是	否	可哈希	否	set(其他)	`v=set()`

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：

v1 = {True, 1}
print(v1)  # {True}

v2 = {1, True}
print(v2)  # {1}

v3 = {0, False}
print(v3)  # {0}

v4 = {False, 0}
print(v4)  # {False}

None类型

Python中有一个特殊的值None类型，表示为空

目前可以转换为False的值有：

0
""
[] or list()
() or tuple()
set()
None

12.7 dict字典类型

字典是无序、键不重复且元素只能是键值对的可变的容器

容器
元素必须是键值对

键不重复，重复则会被覆盖

data = {"k1": 1, "k1": 2}
print(data) # {"k1": 2}

无序（python3.6+之后字典就是有序了，之前字典是无序的）

12.7.1 定义

d1 = {}
d2 = dict()

info = {
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}

字典中对键值对的要求：

键: 必须是可哈希的，目前是: int/bool/str/tuple，不可哈希的类型：list/set/dict;
值：任意类型；

12.7.2 独有功能

1、获取值

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}

age = info.get("age")
print(age)

name = info.get("name")
print(name)

address = info.get("address")
print(address) # None

birth = info.get("birth", "2001-01-28")
print(birth) # 2001-01-28

# 案例
user_list = {
    "alex": "123",
    "admin": "123456"
}

username = input("请输入用户名: ")
password = input("请输入密码: ")
pwd = user_list.get(username)

if pwd == None:
    print("用户名不存在")
else:
    if pwd == password:
        print("登录成功")
    else:
        print("密码错误")
# 写代码的准则：简单的逻辑放在前面，复杂的逻辑放在后面

2、获取所有的键

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
data = info.keys()
print(data) # 输出(["name","age","sex","status","hobby"]) 高仿列表
print(list(data))

注意：在python2中字典.keys()直接获取到的是列表，而python3中返回的是高仿列表，高仿列表可以被循环显示

for key in info.keys():
    print(key)
# 判断某个key是否存在字典中
if "age" in info.keys():
    print("age是字典的键")

3、获取所有的值

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
data = info.values()
print(data) # dict_value(["Alan",12,"male","True",["游戏",读书]])

注意：在python2中字典.values()直接获取到的是列表，而python3中返回的是高仿列表，高仿列表可以被循环显示

for value in info.values():
    print(value)
if 12 in info.values():
    print("12是字典的值")

4、获取所有的键值

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
data = info.items()

print(data) # 输出dict_items() ([('age', 12),("name",Alan),....])

for item in info.items():
    print(item) #item是一个元组
    print(item[0],item[1])
# -------------------
for key,value in info.items():
    print(key,value) #key代表键，value代表值

5、设置值

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
# 没有这个键值是添加，有这个键的话是修改
data.setdefault("salary","15000")

6、批量更新键值对

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
info.update({"age": 18, "name": "Bob"})
print(info) # info中没有的键则直接添加，有的键则是更新值，主打一个批量更新

7、指定移除键值对

info = {"age": 12, "status": True, "name": "Alex"}
data = info.pop("age")
print(info) # {"status": True, "name": "Alex"}
print(data) # 12

8、按照顺序移除（后进先出）

info = {"age": 12, "status": True, "name": "Alex"}
data = info.popitem()
print(info) # {"age": 12, "status": True}
print(data) # {"name": "Alex"}

# 练习题
"""
结合下面的两个变量 header 和 stock_dict实现注意输出股票信息，格式如下：
	SH601778，股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。
    SH688566，股票名称:吉贝尔、当前价:...               。
	...
"""
header = ['股票名称', '当前价', '涨跌额']
stock_dict = {
    'SH601778': ['中国晶科', '6.29', '+1.92'],
    'SH688566': ['吉贝尔', '52.66', '+6.96'],
    'SH688268': ['华特气体', '88.80', '+11.72'],
    'SH600734': ['实达集团', '2.60', '+0.24']
}

for key,value in stock_dict.items():
    # 'SH601778', ['中国晶科', '6.29', '+1.92']
    textList = list()
    for index in range(len(header)):
        str = "{0}: {1}".format(header[index],value[index])
        textList.append(str)
    print("{0}, {1}".format(key, ", ".join(textList)))

12.7.3 公共功能

1、求并集（python3.9加入）

v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}

v3 = v1 | v2
print(v3) # {"k1": 1, "k2": 22, "k3": 33}

2、长度

info = {"age": 12, "status": True, "name": "Alex"}
print(len(info)) # 3

3、是否包含

info = {"age": 12, "status": True, "name": "Alex"}
v1 = "age" in info
print(v1) # true

v2 = "age" in info.keys()

4、索引(键)

字典区别于元组和列表，字典的索引是键，而列表和元组则是0 1 2

info = {"age": 12, "status": True, "name": "Alex"}
print(info["age"]) # 输出12
print(info["staus"]) # 输出True
print(info["xxx"]) # 报错

# 建议使用 info.get("key")

5、根据键修改值和添加值和删除键值对

info = {"age": 12, "status": True, "name": "Alex"}
info["gender"] = "男"
print(info) #{"age": 12, "status": True, "name": "Alex","gender": "男"}

info = {"age": 12, "status": True, "name": "Alex"}
del info["age"] # 保证键存在，才能删除
print(info) # {"status": True, "name": "Alex"}

6、for循环

info = {"age": 12, "status": True, "name": "Alex"}
for key in info.keys():
    print(key)
for value in info.values():
	print(value)
for key,value in info.items():
    print(key, value)

12.7.4 转换

想要转换为字典.

v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )

print(v) # { "k1":"v1", "k2":"v2" }

info = { "age":12, "status":True, "name":"武沛齐" }

v1 = list(info)        # ["age","status","name"]

v2 = list(info.keys()) # ["age","status","name"]

v3 = list(info.values()) # [12,True,"武沛齐"]

v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","武沛齐") ]

12.7.5 其他

12.7.5.1 存储原理

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

12.7.5.2 速度快

info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
for "alex" in info:
    print("在"）

info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")

12.7.6 嵌套

我们已学了很多数据类型，在涉及多种数据类型之间的嵌套时，需注意一下几点：

字典的键必须可哈希（list/set/dict不可哈希）。

info = {
    (11,22):123
}

# 错误
info = {
    (11,[11,22,],22):"alex"
}

字典的值可以是任意类型。

info = {
    "k1":{12,3,5},
	"k2":{"xx":"x1"}
}

字典的键和集合的元素在遇到布尔值和 1、0 时，需注意重复的情况。
元组的元素不可以被替换。

dic = {
	'name':'汪峰',
	'age':48,
	'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],
	'children':['第一个娃','第二个娃']
}
"""
1. 获取汪峰的妻子名字
	d1 = dic['wife'][0]['name']
	print(d1)
2. 获取汪峰的孩子们
	d2 = dic['children']
	print(d2)
3. 获取汪峰的第一个孩子
	d3 = dic['children'][0]
	print(d3)
4. 汪峰的媳妇姓名变更为 章子怡
	dic['wife'][0]['name] = "章子怡"
	print(dic)
5. 汪峰再娶一任妻子
	dic['wife'].append( {"name":"铁锤","age":19} )
	print(dic)
	
6. 给汪峰添加一个爱好：吹牛逼
	dic['hobby'] = "吹牛逼"
	print(dic)
7. 删除汪峰的年龄
	del dic['age']
	或
	dic.pop('age')
	print(dic)
"""

12.8 float浮点型

v1 = 3.14
v2 = 9.99

在类型转换时，浮点型转为整型，会将小数部分去掉

v1 = 3.4
print(int(v1)) # 3

保留小数点后N位

v1 = 3.1415926
print(round(v1, 3)) # 3.142

浮点型的坑

import decimal

v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3

三笠·阿卡曼

关注

25
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
Python基础学习（一）

age = 99user_list = ["李白","苏轼","辛弃疾"]data_list = [1,True,"Alan", "张楚岚"]user_list.append("盖聂")print(user_list) # ["盖聂",123,False]不可变类型：字符串、布尔、整型可变类型：列表v2 = ("小明","Alan")# 建议：在元组的最后一个元素后面多加一个逗号，用来表示它是一个元组无序：无法通过索引定位值可变：可以添加和删除元素v1.add(44)不允许数据重复。
复制链接

扫一扫