第八课（集合、可变类型和不可变类型、函数（一））

最新推荐文章于 2022-09-17 17:52:05 发布

weixin_44831124

最新推荐文章于 2022-09-17 17:52:05 发布

阅读量223

点赞数

文章标签： python

本文链接：https://blog.csdn.net/weixin_44831124/article/details/114607390

版权

集合、可变类型和不可变类型、函数（一）

一.集合简介
二.可变类型与不可变类型
三.函数(上)
作业

一.集合简介

1.集合表现形式set

创建空集合

#集合表现形式set.  符号 {}
#创建空集合
#创建空集合需要用到set()函数。
s = {}
x = set()
print(type(s))
print(type(x))
'''
输出为：
<class 'dict'>  不使用set()，只使用{}时，创建的是空字典。
<class 'set'>
'''

2.集合和列表非常相似，与列表的不同点：

集合只能存储不可变对象

#集合只能存储不可变对象
s = {1,2,"abc",[4,5,6]}
print(type(s))
'''
输出为：
Traceback (most recent call last):
  File "F:/python/第8课/集合.py", line 15, in <module>
    s = {1,2,"abc",[4,5,6]}
TypeError: unhashable type: 'list'
'''

集合中存储的对象是无序的

#集合中存储的对象是无序的
s2 = {1,5,8,3,6,0,4}
print(s2)
'''
输出为：
{0, 1, 3, 4, 5, 6, 8}
'''

集合不能出现重复元素（可利用集合这一特性，来达到去重的效果。）

# 集合不能出现重复元素
s3 = {1,2,3,4,1,2,3,4}
print(s3)
'''
输出为：
{1, 2, 3, 4}
'''

可以通过set()来将序列和字典转换成集合

# 可以通过set()来将序列和字典转换成集合
list1 = [1,2,3]
dict1 = {"name":"俞棚玮"} 
print(set(list1))
print(set(dict1))
'''
输出为：
{1, 2, 3}
{'name'}
'''

len() 使用len()来获取集合中元素的数量

#len() 使用len()来获取集合中元素的数量
set1 = {1,4,5,7}
print(len(set1))
'''
输出为：
4
'''

in、not in 判断是否在集合中。

#in、not in 判断是否在集合中。
set2 = {1,4,5,7}
print(1 in set2)
print(2 in set2)
print(1 not in set2)
print(2 not in set2)
'''
输出为：
True
False
False
True
'''

add()像集合中添加元素

#add()像集合中添加元素
set3 = set()
set3.add(1)
set3.add(2)
print(set3)
'''
输出为：
{1, 2}
'''

update()将一个集合中的元素添加到另一个集合当中

#update()将一个集合中的元素添加到另一个集合当中
set4 = {1,2,3}
set5 = {4,5}
set4.update(set5)
print(set4)
'''
输出为：
{1, 2, 3, 4, 5}
'''

pop()随机删除集合中的一个元素一般是删除第一个元素

#pop()随机删除集合中的一个元素一般是删除第一个元素
set6 = {1,2,3,4,5,6,7,8}
set6.pop()
print(set6)
'''
输出为：
{2, 3, 4, 5, 6, 7, 8}
'''

remove() 删除集合中指定的元素

# remove() 删除集合中指定的元素
set7 = {1,2,3,4,5,6,7,8}
set7.remove(2)
print(set7)
'''
输出为：
{1, 3, 4, 5, 6, 7, 8}
'''

clear() 清空集合

# clear() 清空集合
set8 = {1,2,3,4,5,6,7,8}
set8.clear()
print(set8)
'''
输出为：
set()
'''

3.集合的运算

& 交集运算

set9 = {1,2,3,4,7,8}
set10 = {4,5,6,9,7,8}
# & 交集运算
s3 = set9 & set10
print(s3)
'''
输出为：
{8, 4, 7}
'''

| 并集运算

set9 = {1,2,3,4,7,8}
set10 = {4,5,6,9,7,8}
# | 并集运算
s4 = set9 | set10
print(s4)
'''
输出为：
{1, 2, 3, 4, 5, 6, 7, 8, 9}
'''

- 差集运算

set9 = {1,2,3,4,7,8}
set10 = {4,5,6,9,7,8}
# - 差集运算
s5 = set9 - set10
print(s5)
'''
输出为：
{1, 2, 3}
'''
s6 = set10 - set9
print(s6)
'''
输出为：
{9, 5, 6}
'''

^ 亦或集

set9 = {1,2,3,4,7,8}
set10 = {4,5,6,9,7,8}
# ^ 亦或集
s7 = set9 ^ set10
print(s7)
'''
输出为：
{1, 2, 3, 5, 6, 9}
'''

<= 检查一个集合是否是另一个集合的子集

# <= 检查一个集合是否是另一个集合的子集
set11 = {1,2,3,4,5,6,7}
set12 = {1,2,3}
set13 = {9,10}
print(set12 <= set11)
print(set13 <= set11)
'''
输出为：
True
False
'''

< 检查一个集合是否是另一个集合的真子集

# < 检查一个集合是否是另一个集合的真子集
set11 = {1,2,3,4,5,6,7}
set12 = {1,2,3,}
set13 = {1,2,3,4,5,6,7}
print(set12 < set11)
print(set13 < set11)
'''
输出为：
True
False
'''

=检查一个集合是否是另一个集合的超集

# >=检查一个集合是否是另一个集合的超集
set11 = {1,2,3,4,5,6,7}
set12 = {1,2,3}
set13 = {1,2,3}
print(set11 >= set12)
print(set13 >= set12)
'''
输出为：
True
True
'''

>检查一个集合是否是另一个集合的真超集

# >检查一个集合是否是另一个集合的真超集
set11 = {1,2,3,4,5,6,7}
set12 = {1,2,3}
set13 = {1,2,3}
print(set11 > set12)
print(set13 > set12)
'''
输出为：
True
False
'''

二.可变类型与不可变类型

可变类型（mutable）：列表，字典（key是不可变），集合
- 里面的元素改变了，但是他的id还是不会变化。
不可变类型（unmutable）：int，float，字符串，元组
- 里面的元素改变了，那么他的id也就发生了变化
这里的可变不可变，从对象内存地址方向来说，是指内存中的值（value）是否可以被改变。
python所声明的变量都以对象的形式存在，存在于机器的固定内存之中。

# 字符串的更改
str1 = 'abc'
print(id(str1))
# 运行结果 》》》2480058428696

str2 = str1.replace('a', 'b')   # 将字符串中的a换成b
print(id(str2))
# 运行结果 》》》2480059406632

a = 'abc'
print(id(a))
# 运行结果 》》》2480058428696

a = 'bcd'
print(id(a))
# 运行结果 》》》2480059406352

# 列表更改
list1 = [1, 2, 3, 4]
print(id(list1))
# 运行结果 》》》2480058553160

list1.remove(4)   # 删除4这个元素
print(id(list1))
# 运行结果 》》》2480058553160

通过上述代码，我们就可以很直观的看到ID的变换，不可变类型的字符串，只要更改，ID就会随之改变，可变类型的列表，不管怎么更改，还是原先的ID

三.函数(上)

1. 函数简介

函数也是一个对象
函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用。

#语法
def 函数名([形参1,形参2,形参3....]):
    代码块
#调用
函数名（实参1，实参2.....）

注意：

函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)

print是函数对象，print()是调用函数

2. 函数的参数

2.1形参和实参

- 形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值
- 实参(实际参数)指定了形参，那么在调用函数时必须传递实参，实参将会赋值给对应的形参，简单来说有几个形参就要有几个实参

# 需求： 定义一个函数求任意2个数的和
# 在函数中定义形参，相当于在函数内声明了变量
def fun(a, b):   # a, b  是形参  就是形式上的参数  ，你如果定义了形参，那么就必须在调用的时候传递实参
    print(a + b)
fun(1, 2)  # 1, 2 是实参，也就是实际参数
'''
输出为：
3
'''

2.2函数的传递方式

定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效

def fun(a,b,c=20):
    print(a)
    print(b)
    print(c)

fun(1,2)
'''
输出为：
1
2
20
'''

def fun(a,b,c=20):
    print(a)
    print(b)
    print(c)

fun(1,2,3)
'''
输出为：
1
2
3
'''

位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参

def fun(a,b,c):
    print(a)
    print(b)
    print(c)

fun(1,2,3)
'''
输出为：
1
2
3
'''

关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递

def fun(a,b,c):
    print(a)
    print(b)
    print(c)

fun(c=1,a=2,b=3)
'''
输出为：
2
3
1
'''

混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去

def fun(a,b,c):
    print(a)
    print(b)
    print(c)

fun(1,c=2,b=3)
'''
输出为：
1
3
2
'''

def fun(a,b,c):
    print(a)
    print(b)
    print(c)

fun(1,a=2,b=3)
'''
输出为：
fun() got multiple values for argument 'a'
'''

2.3不定长参数

定义函数时，可以在形参前面加一个*,这样这个形参可以获取到所有的实参，它会将所有的实参保存到一个元组中。
不定长参数一般使用*args表示。
带*号的形参只能有一个，可以和其他参数配合使用。
*args必须放到位置参数后面, 放到关键字参数的前面
*args只能接受位置参数，不能接受关键字参数
**形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值
**形参只有一个，并且必须写在所有参数的后面，一般使用**kwargs表示。

不定长参数在一个函数中不管是*args还是**kwargs都只能存在一个，而且*args必须要在**kwargs之前。

2.4参数的传递类型

任意类型的参数都是可以传递的
包括：int(整型)；float(浮点型)；string(字符串)；bool(布尔值)；None(空值)；list(列表)；tuple(元组)；dict(字典)；set(集合)；fun（函数对象）。。。
不同类型的参数传递后的改变

# 不可变类型 int
def fun2(a):  # a = b = 1
    a = 10
    print(a)

b = 1
fun2(b)
print(b)
# 运行结果 》》》
10
1

# 可变类型 list
def fun3(a):  # a = b = [1, 2, 3]
    a[2] = 10
    print(a)

b = [1, 2, 3]
fun3(b)
print(b)
# 运行结果 》》》
[1, 2, 10]
[1, 2, 10]

2.5参数的解包

传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递
要求序列中的元素的个数必须和形参的个数一致

def fun(a, b, c):
    print(a, b, c)

# 元组的拆包
t = (4, 5, 6)
fun(t[0], t[1], t[2])    # 通过索引取值为实参
# 运行结果 》》》4 5 6
fun(*t)					 # args不定长参数取值
# 运行结果 》》》4 5 6

# 字典的拆包
t = {'a': 1, 'b': 2, 'c': 3}		# kargs不到场参数取值
fun(**t)

字典的拆包需要注意key，key值必须与形参定义的一样，比如形参是abc，key也必须是abc

def fun(a, b, c):
    print(a, b, c)

# 字典的拆包
t = {'y': 1, 'b': 2, 'c': 3}		#形参中没有y，所以拆包会报错
fun(**t)
'''
输出为：
fun() got an unexpected keyword argument 'y'
'''

作业

打印名片程序:输入姓名，电话号码，性别，最后打印出来名片
• 控制姓名长度为6-20
• 电话号码长度11
• 性别只能允许输入男或女
• 每一样信息不允许为空

# 1. 打印名片程序:输入姓名，电话号码，性别，最后打印出来名片
# • 控制姓名长度为6-20
# • 电话号码长度11
# • 性别只能允许输入男或女
# • 每一样信息不允许为空
def mingpian_fun(name,tel,sex):
    if len(name) < 6 or len(name) > 20:
        print("你输入的姓名长度有误")
        return 0
    if len(tel) != 11 or tel.isdigit() ==  False:
        print("你输入的电话格式长度有误")
        return 0
    if (sex != "男" and sex != "女"):
        print("你输入的性别格式不符")
        return 0
    print(name)
    print(tel)
    print(sex)
    return 0

name = input("请输入姓名:")
tel = input("请输入电话号码:")
sex = input("请输入性别:")
mingpian_fun(name,tel,sex)

使用函数求前20个斐波那契数列斐波那契数列：1,1,2,3,5,8,13,21…即: 起始两项均为1，此后的项分别为前两项之和

# 2. 使用函数求前20个斐波那契数列斐波那契数列：1,1,2,3,5,8,13,21...即: 起始两项均为1，此后的项分别为前两项之和
def fbnqsl_fun(n):
    a = []
    s = 0
    if n > 0:
        for i in range(n+1):
            if i == 0:
                pass
            elif i == 1:
                a.append(1)
            elif i == 2:
                a.append(1)
            else:
                s = a[i-3] + a[i-2]
                a.append(s)
    else:
        print("输入数据出错")
    return a

print(fbnqsl_fun(20))
'''
输出为：
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
'''

编写一段代码，定义一个函数求1-100之间所有整数的和，并调用该函数打印出结果

# 3. 编写一段代码，定义一个函数求1-100之间所有整数的和，并调用该函数打印出结果
def add_fun():
    s = 0
    for i in range(101):
        s +=i
    return s


print(add_fun())

weixin_44831124

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
3
评论
第八课（集合、可变类型和不可变类型、函数（一））

集合、可变类型和不可变类型、函数（一）集合简介1.集合表现形式set2.集合和列表非常相似，与列表的不同点：3.集合的运算二级目录三级目录集合简介1.集合表现形式set创建空集合#集合表现形式set. 符号 {}#创建空集合#创建空集合需要用到set()函数。s = {}x = set()print(type(s))print(type(x))'''输出为：<class 'dict'> 不使用set()，只使用{}时，创建的是空字典。<class 'se
复制链接

扫一扫