Python基础学习(一)

Python基础语法学习记录

输出

将结果或内容呈现给用户

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

Python基础学习(一)_第1张图片

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 * "我想吃拉面")

Python基础学习(一)_第2张图片

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("登录失败")

Python基础学习(一)_第3张图片

补充:

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变量名则指向这块区域。

image-20201011163312491

情景二

name = "sushi"
name = "alex"

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

image-20201011163344305

情景三

name = "sushi"
new_name = name

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

image-20201011163427166

情景四

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

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

image-20201011163503412

情景五

num = 18
age = str(num)

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

Python基础学习(一)_第4张图片

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 算数运算符

Python基础学习(一)_第5张图片

9.2 比较运算符

Python基础学习(一)_第6张图片

9.3 赋值运算

Python基础学习(一)_第7张图片

9.4 成员运算

Python基础学习(一)_第8张图片

9.5 逻辑运算

image-20240101153946726

10. Python数据类型

常见数据类型:

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

Python基础学习(一)_第9张图片

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(长整型),他们都是整数只不过能表示的值范围不同。

image-20201102190227431
  • 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|[email protected]"
result = data.split('|') # ["Alan","root","[email protected]"]
result2 = data.split('|', 1) # 切一个,遇到第一个切
result3 = data.rsplit('@') #
print(data) # "Alan|root|[email protected]"
print(result) # 输出 ["Alan","root","[email protected]"] 根据特定字符切开之后保存在列表中,方便以后的操作
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 集合的存储原理
image-20201120193837492
12.6.5.2 元素必须可哈希

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

image-20201120190454120

目前可哈希的数据类型: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 存储原理

Python基础学习(一)_第10张图片

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
  • 浮点型的坑

    Python基础学习(一)_第11张图片

import decimal

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

你可能感兴趣的:(python,学习,开发语言)