python基本数据类型、字典、 集合、条件与循环控制、函数（3）

目录

一、python基本数据类型。

Number。

bytes类型。(二进制序列)

二、python字典。

字典的创建。

字典核心操作。(增删改查)

字典相关常用内置方法。

三、python集合。

集合的创建。

集合间的运算。

集合的常用基本操作。

四、python条件控制、循环语句。

if-else。if-elif-else。

[match...case。(python 3.10+可用)](#match...case。(python 3.10+可用))

for循环、while循环。

循环控制：break、continue、else。

pass语句。

五、python函数。

函数定义与创建。

函数传不可变对象实例。

函数传可变对象实例。

位置参数(必需/顺序参数)。

关键字参数。

默认参数。

可变参数。

*vartupl/*args。(打包元组)

**var_args_dict/**kwargs。(打包字典)

[可变参数的 "解包" 操作。](#可变参数的 “解包” 操作。)

---

一、python基本数据类型。

• Python中常见的数据类型有：Number(数字)、String(字符串)、bool(布尔)、List(列表)、Tuple(元组)、Set(集合)、Dictionary(字典)。

---

• 其中：不可变数据：Number、String、Tuple。可变数据：List、Dictionary、Set。不可变不是意味着值能不能改变，而是指 "对象本身能不能被修改"。
• **不可变数据：**对象创建后，其内存中的内容不能被直接修改。如果要 "改值"，必须创建一个新的对象，原来的对象保持不变。
• **可变数据：**对象创建后，其内存中的内容可以直接修改。"改值" 时不会创建新对象，还是原来的那个对象。

s1 = "hello"
print(id(s1))  #内存地址id()：2408659334848

s1 += "world"
#不可变数据类型String的内存地址发生改变
print(id(s1))  #新内存地址：2408659463216

l1 = [1,"hello"]
print(id(l1))  #内存地址：3157294884480
#可变数据类型List的内存地址未发生改变
l1.append("world")
print(id(l1))  #内存地址：3157294884480

Number。

• Python3 支持 int、float、bool、complex（复数）。在Python 3里，只有一种整数类型 int，表示为长整型，没有Long。

#type() 函数可以用来查询变量所指的对象类型
a = 100
print(type(a))  #<class 'int'>

#isinstance可用来判断
print(isinstance(a, int))  #True
print(isinstance(a, float))  #False
print(isinstance(a, complex))  #False

• Python3中，bool 是 int 的子类。
• True 和 False 可以和数字相加。也就是True 等价于 1。

b1 = True
b2 = False
b3 = True
print(b1 + b2)  #1
print(b1 + b3)  #2
print(b1 - b3)  #0
print(b2 - b3)  #-1

bytes类型。(二进制序列)

#bytes 创建

#直接使用b前缀
b1 = b"hello"
print(b1)  #b'hello'
print(type(b1)) #<class 'bytes'>
#截取
print(b1[0]) #104 'h'的ASCII码值

#bytes()函数创建  参数：整数、可迭代对象、字符串+编码
#参数为整数：创建 n 个值为 0 的字节
b2 = bytes(3)
print(b2)  #b'\x00\x00\x00'  #\x00 表示值为 0 的字节

#可迭代对象
b3 = bytes([65,66,67])
print(b3)   #b'ABC'

#字符串+编码
s = "你好"
b4 = s.encode("utf-8")
print(b4)  #b'\xe4\xbd\xa0\xe5\xa5\xbd' #中文在 utf-8 中占3字节
#使用utf8解码
s2 = b4.decode("utf-8")
print(s2)  #你好

二、python字典。

• 字典也是一种可变容器模型，且可存储任意类型对象。
• 字典是键值对（key-value） 结构的集合。它每个键值 key=>value 使用冒号 (:) 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中。基本格式如下：

dict01 = {key1 : value1, key2 : value2, key3 : value3 ... }

• 键必须是唯一的，但值则不必。

• 其中字典的值value可以取任何数据类型（如：数字、字符串、列表、字典等），但键key必须是不可变的（如字符串，数字、元组等，且重复键会被覆盖）。

#重复的键会被最后一个覆盖
d = {"a":1,"a":2}
print(d)  #{'a': 2}

字典的创建。

person = {"name":"小米", "age":18}
print(person)  #{'name': '小米', 'age': 18}

#空字典
empty = {}
print(empty)  #{}

#使用dict()函数创建字典
student = dict(name="小红", age=22 ,grade="大学")
print(student)   #{'name': '小红', 'age': 22, 'grade': '大学'}

字典核心操作。(增删改查)

person = {"name":"小米", "age":18}
print(person)  #{'name': '小米', 'age': 18}

#键名查询
print(person["name"])  #小米
print(person["age"])   #18
#不存在该键
print(person["grade"])  #KeyError: 'grade'

#get查询
print(person.get("name"))  #小米
print(person.get("age"))   #18
#不存在该键
print(person.get("grade"))  #None
#若不存在，可指定值
print(person.get("grade","高三"))  #高三

person = {"name":"小米", "age":18}
print(person)  #{'name': '小米', 'age': 18}

#新增
#键不存在时，赋值就是新增
person["height"] = 180
print(person)  #{'name': '小米', 'age': 18, 'height': 180}

#修改
person["age"] = 20
print(person["age"])  #20

#删除
#del直接删除
del person["height"]
print(person)  #{'name': '小米', 'age': 20}

#pop删除并返回删除的值
age = person.pop("age")
print(age)  #20
print(person)  #{'name': '小米'}

#清空所以键值对
person.clear()
print(person)   #{}

字典相关常用内置方法。

d = {"name":"小芳", "age":18, "height":165}

#字典元素个数
print(len(d))  #3

#输出字典字符串
print(str(d))  #{'name': '小芳', 'age': 18, 'height': 165}

#输入变量的类型
print(type(d))  #<class 'dict'>

#获取所有键，返回视图对象
print(d.keys())  #dict_keys(['name', 'age', 'height'])

#获取所有值
print(d.values())  #dict_values(['小芳', 18, 165])

#获取所有键值对，每一个键值对是一个元组
print(d.items())  #dict_items([('name', '小芳'), ('age', 18), ('height', 165)])

#键是否存在字典中
print("name" in d)  #True
print("weight" in d)  #False

三、python集合。

• 集合（set）是一个无序的不重复元素序列。
• 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。用大括号 {} 表示（与字典不同，集合里面是单个元素而非键值对）。
• 核心特性：无序、去重：集合无法通过索引访问，自动保留唯一元素。

集合的创建。

#直接使用大括号创建集合
nums = {1,2,"zhang",4,5,2}
#顺序无序且去重
print(nums)  #{1, 2, 'zhang', 4, 5}
print(type(nums))  #<class 'set'>

#使用set函数创建集合
#列表转集合
set2 = set([2,1,3,4])
print(set2)  #{1, 2, 3, 4}
print(type(set2))  #<class 'set'>
#字符串转集合
set3 = set("hello")
print(set3)  #{'o', 'e', 'l', 'h'}
print(type(set3))   #<class 'set'>

• 注：空集合的创建。

#空集合必须用set()创建
set_empty = set()
print(set_empty)  #set()
print(type(set_empty))  #<class 'set'>
#若使用{}创建空集合，会变成一个空字典
set_empty2 = {}
print(set_empty2)   #{}
print(type(set_empty2))  #<class 'dict'>

集合间的运算。

#集合运算
set1 = set('abc')
set2 = set('bcdf')
print(set1)  #{'b', 'c', 'a'}
print(set2)  #{'d', 'b', 'c', 'f'}

#set1 - set2 set1包含,set2不包含
print(set1-set2)  #{'a'}

#set1 | set2 set1包含或set2包含
print(set2 | set1)  #{'b', 'a', 'f', 'd', 'c'}

##set1 & set2 set1、set2都包含
print(set2 & set1)  #{'b', 'c'}

#不同时包含在set1或不同时包含在set2
print(set2 ^ set1)  #{'a', 'f', 'd'}

集合的常用基本操作。

• 更详细的可前往菜鸟教程学习：https://www.runoob.com/python3/python3-set.html

set1 = {"idea","taobao","meituan"}
print(set1)  #{'meituan', 'idea', 'taobao'}

#判断元素是否存在
print("meituan" in set1)  #True
print("elm" in set1)  #False

#添加元素
set1.add("elm")
print(set1)   #{'elm', 'taobao', 'meituan', 'idea'}

#update()方法添加元素
#参数可以是：列表，元组，字典
set1.update({1,3})  #{1, 'elm', 3, 'meituan', 'idea', 'taobao'}
print(set1)
set1.update(["西瓜","葡萄"])
print(set1)  #{'elm', 1, 'meituan', 'taobao', 'idea', 3, '葡萄', '西瓜'}
set1.update((100,"zzh"),(2888,"qq"))
print(set1)  #{1, 3, '西瓜', 2888, 'meituan', 'zzh', 'elm', 'idea', 100, '葡萄', 'qq', 'taobao'}

set1 = {"苹果","橘子","榴莲"}

#集合元素个数
print(len(set1))  #3

#remove移除
set1.remove("橘子")
print(set1)  #{'榴莲', '苹果'}
#remove移除不存在的元素，报错
#set1.remove("榴莲222")  #KeyError: '榴莲222'

#discard删除
set1.discard("榴莲")
print(set1)  #{'苹果'}
#discard删除不存在的元素，不会报错
set1.discard("香蕉")
print(set1)  #{'苹果'}

#pop随机删除集合中的一个元素
set1.pop()
print(set1) #set()
#集合为空时报错
#set1.pop()  #KeyError: 'pop from an empty set'

#清空集合
set1.clear()
print(set1)  #set()

四、python条件控制、循环语句。

if-else。if-elif-else。

score = 91
if score < 60:
    print("不及格")
elif 60 <= score < 90:
    print("合格")
else:
    print("优秀")

match...case。(python 3.10+可用)

status = input("status：")
print(type(status))  #<class 'str'>
match int(status):
    case 200:
        print("success")
    case 404:
        print("not found")
    case 500:
        print("error")
    case _:  #匹配其他所有
        print("unknown error")

#匹配列表 / 元组的结构
data = [1, 2, 3]
match list(data):
    case [1, x, 3]:
        print(x)  #2
    case [a,b]:
        print(a,b)
    case _:
        print("unknown")

#匹配字典
user = {"name": "小明", "age": 18}  ##18岁用户：小明
user2 = {"name": "小明", "age": 20}  #用户：小明

match user:
    case {"name": name, "age": 18}:
        print(f"18岁用户：{name}")
    case {"name": name}:
        print(f"用户：{name}")

---

for循环、while循环。

#for 循环

fruits = ["苹果", "香蕉", "橘子"]
#苹果
#香蕉
#橘子
for fruit in fruits:
    print(fruit)  #苹果

#h
#i
s = "hi"
for char in s:
    print(char)

#range(3) 0,1,2 从0开始左闭右开
#0
#1
#2
for i in range(3):
    print(i)

#while循环
#0
#1
#2
#3
#4
count = 0
while count < 5:
    print(count)
    count += 1

循环控制：break、continue、else。

• 循环的else子句：循环正常结束 （未被break中断）时执行。否则else子句代码不执行。

#循环控制

#break
#0
#1
#2
for i in range(5):
    if i == 3:
        break
    print(i)

#continue
#0
#1
#3
#4
for i in range(5):
    if i == 2:
        continue
    print(i)

#循环的else子句
#0
#1
#2
#else子句执行
for i in range(3):
    print(i)
else:
    print("else子句执行")

#循环被break中断,else子句不执行
#0
#1
for i in range(3):
    if i == 2:
        break
    print(i)
else:
    print("else子句执行")

pass语句。

• pass 是 python 中的空语句 ，它不执行任何操作，仅作为「占位符」使用。
• 当语法上需要一条语句，但你暂时不想写具体代码时，用 pass 填充，避免程序报错。
• 注释（#）会被 Python 解释器直接忽略，不算作语句。

#python 是缩进敏感的语言
#pass语句常用场景
#if/elif/else中
age = 18
if age >= 18:
    pass
else:
    print("18 -")

#循环中
for i in range(5):
    pass

#函数中,但未实现功能
def sum_me(a,b):
    pass

#定义类,但未完善
class Student:
    pass

五、python函数。

• 函数是组织好的，可重复使用的(复用)，用来实现单一，或相关联功能的代码段。
• python提供了许多内建函数，自己创建的就是自定义函数。

---

函数定义与创建。

• 函数使用 def关键词开头，后接函数标识符名称和圆括号 ()，函数内容以冒号 (:) 起始，并且缩进。

#函数最简单的创建与声明
def hello():
    print("hello world!")

#带参数与返回值的函数
def add(a,b):
    return a+b


print(__name__)  #__main__
if __name__ == "__main__":
    hello()
    result = add(1,2)  #hello world!
    print(result)  #3

函数传不可变对象实例。

#函数传不可变对象实例
def change(a):
    print(id(a))  #形参a地址 -指向的是同一个对象  #140714045502376
    a = 10
    print(id(a))  #一个新对象  #140714045502664

a = 1
print(id(a)) #实参a地址  #140714045502376
change(a)

函数传可变对象实例。

#函数传可变对象实例
def changeme(mylist):
    mylist.append([1,2,3,5])
    print("函数内取值：",mylist)  #函数内取值： [1, 2, 3, [1, 2, 3, 5]]
    print(id(mylist))  #2126904731264
    return

mylist = [1,2,3]
print(id(mylist)) #2126904731264
changeme(mylist)  #传可变对象实例
#传入函数的和在末尾添加新内容的对象用的是同一个引用
print("函数外取值：",mylist)  #函数外取值： [1, 2, 3, [1, 2, 3, 5]]

位置参数(必需/顺序参数)。

#位置参数
#必须按参数定义的顺序传入，数量要一致
def introduce(name,age):
    print(f"我叫{name}，今年{age}岁")

introduce("利尔湖",180)  #我叫利尔湖，今年180岁

关键字参数。

#关键字参数
#按参数名传参，顺序可换
def introduce(name,age):
    print(f"我叫{name}，今年{age}岁")

introduce(age=18,name="小明")  #我叫小明，今年18岁

默认参数。

#默认参数
def introduce(name,age,country="中国"):
    print(f"我叫{name}，今年{age}岁，来自{country}")

introduce(age=28,name="小王")   #我叫小王，今年28岁，来自中国

可变参数。

*vartupl/*args。(打包元组)

• 命名习惯约束，可自定义。

• 它会把传入的多个位置参数打包成一个元组（tuple），在函数内部可以像操作元组一样访问这些参数

#接收任意数量的参数
def sum_all(*args):
    print("元组：",args)  #元组： (1, 2, 3)
    total = 0
    for num in args:
        total += num
    return total

#与普通参数结合必须在它之后
def show_info(name, age, *hobbies):
    print(f"姓名：{name}，年龄：{age}")  #姓名：小花，年龄：20
    print(f"爱好：{hobbies}")  #爱好：('篮球', '跑步', '游泳')

print(sum_all(1,2,3))  #6
show_info("小花",20,"篮球","跑步","游泳")

---

**var_args_dict/**kwargs。(打包字典)

• 命名习惯约束，可自定义。
• 它会把传入的多个关键字参数（ key=value 形式） 打包成一个字典（dict），在函数内部可以像操作字典一样访问这些参数（通过键获取值）。

#接收任意数量的参数
def print_info(**kwargs):
    print(kwargs)
    for k,v in kwargs.items():
        print(f'{k}: {v}')

#name: 小明
#age: 18
#gender: 男
print_info(name="小明", age=18, gender="男")   #{'name': '小明', 'age': 18, 'gender': '男'}
#city: 北京
#temperature: 30
#weather: 晴天
print_info(city="北京", temperature=30, weather="晴天")  #{'city': '北京', 'temperature': 30, 'weather': '晴天'}

#**kwargs 与普通参数、*args 结合使用
#必须按照顺序：普通参数 -> *args -> **kwargs
def func(a, b, *args, **kwargs):
    print("普通参数a：", a)  #1
    print("普通参数b：", b)  #2
    print("元组：", args)  #元组： (100, 1000)
    print("字典：", kwargs)  #字典： {'x': 99, 'y': 999}

func(1,2,100,1000,x=99,y=999)

可变参数的 "解包" 操作。

#可变参数"解包"
#用*解包列表 / 元组
def add(a, b, c):
    return a + b + c

nums = [10,100,1000]
print(add(*nums))  #1110

nums_tuple = (1, 2, 3)
print(add(*nums_tuple))  #6

#可变参数"解包"
#用 ** 解包字典
def introduce(name, age):
    print(f"我叫{name}，今年{age}岁")

info = {"name": "老大", "age": 24}
introduce(**info)  #我叫老大，今年24岁

---