自学python所记(九)

14.6、补充:列表去重

面试题可能出现

列表去重:列表中存在多个数据,需求,去除列表中重复的数据
方式1:思路
遍历原列表中的数据判断新列表是否存在,如果存在,不管,如果不存在放入新列表
遍历:for 循环使用
判断是否存在:可以 使用 in
存入数据:append()

方式2:
在python中还有一种数据类型(容器),称为是 集合(set)
特点:集合中不能有重复数据(如果有重复的数据会自动去重)
可以使用集合的特点对列表去重

1.使用set()类型转换将列表转换为集合 集合为类型
2.再使用list()类型转换将集合转换为列表

缺点:不能保证数据在原列表中出现的顺序(一般来说,也不考虑这件事)
list1=[1,2,3,4,2,3,12,4,1]
list2=set(list1)
print(list2)

14.7、函数的参数

# 1、定义一个函数,my_sum,对两个数字进行求和计算。


def my_sum():
    num1=10
    num2=20
    num = num1+num2
    print(num)
    
my_sum()

# 函数存在的问题,这个函数只能对10和20进行求和,不能对任意的函数进行求和
#问题解决: 想要解决这个额问题,可以使用函数参数来解决

函数参数:在函数定义的时候,使用变量代替具体的数据值(进行占位),
        在函数调用的时候,传递具体的数据值。
好处:让函数更加通用,能够解决一类问题,而不是单纯的一个

# num1和num2 是函数定义时候的参数,起到占位的作用,没有具体的数据值,称为形式参数,简称 形参
def my_sum(num1,num2):  
    num = num1+num2  # 函数中使用的数据会变化时,就可以定义为参数
    print(num)
    
my_sum(10,20)  # 在函数调用的时候,括号中的数据会传递给形参,是具体的数据值,称为实际参数,简称 实参

# 目前书写的函数,在定义的时候如果有形参,那么在调用的时候,必须传递实参值,个数要对应,否则会出错
格式:定义函数前后空两行

14.8、函数的返回值

函数的返回值,可以理解为是 函数整体执行的结果是什么

什么时候需要书写返回值:函数中得到的数据在后续的代码中还要使用,这个时候就应该将这个数据作为返回值返回,以供后续使用

print()--->None
input()--->键盘输入的内容
type() --->类型
len()  --->数据的长度(元素的个数)

在函数中想要将一个数据作为返回值 返回,需要使用return关键字(只能在函数中使用)
作用:
1.将数据值作为返回值返回
2.函数代码执行遇到return,会结束函数的执行
def my_sum(num1, num2):
    num = num1 + num2  # 函数中使用的数据会变化时,就可以定义为参数
    print(num)  # 代码中没有返回值,只有print,这个结果 只能在函数中用一次,不能后续使用
    # 想要将这个求和的结果 在后续代码中使用,需要使用return将求和的结果进行返回
    return num  # 将这个结果返回调用的地方 


# 1.函数中没有print,只有return,想要查看结果,需要在调用的时候使用 print
print(my_sum(1, 2))

# 2.想要将函数中返回的结果,在后续代码中使用,即需要将这个数据保存下来,

#   如果函数有返回值,在调用的时候,需要使用变量来接收(保存)函数的返回值

# 变量 = 函数()
result = my_sum(10, 20)  # 将求和的结果保存到变量 result中,可以在后也许代码中使用

# 后续使用
print('使用:1.直接打印:', result)
print('使用:2.对数字加10:', result + 10)


返回多个数据值,一般使用逗号将多个数据隔开,组成元组,进行返回
  • 返回值 的说明

    def 函数名():  # 返回值None
        pass  # 代码中没有return
    
    def 函数名()return  # return 后面没有数据,返回值None
    
    def 函数名():
        return xx  # 返回值是xx
    
    

14.9、变量的进阶、id(理解

变量的引用

1.在定义变量的时候 变量=数据值,python解释器会在内存中开辟两块空间
2.变量和数据都有自己的空间
3.可理解为,将数据保存到变量的内存中,本质是将 数据的地址保存到变量对应的内存
4.变量中存储数据地址的行为 就是引用(变量引用了数据的地址,简单说就是变量中存储数据

5.可以使用id() 来获取变量中的引用地址(即数id据的地址),如果两个变量的id()获取的引用地址一样,即代表着,两个变量引用了同一个数据,是同一个数据

6.只有赋值运算符 = ,可以改变变量的引用(等号左边数据的引用)
7.python中数据的传递,们都是传递的引用
a = 1  # 将数据1 的地址,存到a对应的内存中
print(id(a))

b = a  # 将数据a中的引用 保存到变量b中
print('b:', id(b))

a = 10  # 将数据10的地址保存到a对应的地址,即a的引用变了
print('a:', id(a))

print('b:', id(b))

输出:
1648048734448
b: 1648048734448
a: 1648048734736
b: 1648048734448

14.10、可变类型和不可变类型

数据类型:int  float   bool  str  list  tuple  dict  set

可变不可变是指:数据所在的内存是否允许被修改,允许修改就是可变类型,不允许修改就是不可变类型(不使用=,变量引用的数据)

可变类型:列表list, 字典dict,  集合set
  列表.append()
  字典.pop(键)
不可变类型:int  float  bool  str  tuple
my_list = [1, 2, 3]
my_list1 = [1, 2, 3]
print('my_list:', id(my_list))
print('my_list1:', id(my_list1))

# my_list: 2470301722240
# my_list1: 2470301691776

my_list[1]=10 # 这里修改的是列表中下表为1的位置引用
print(id(my_list))  # 列表的引用没有发生变化
tuple1 = (1, 2, [3.4])  # 元组中存储的是1的地址,2的地址,和列表的地址
# 元组中的数据不能改变,是指 这三个地址不能改变
print(tuple1,id(tuple1))
tuple1[-1][0] = 10  # 修改的是列表中下表为0的位置的引用地址,列表的地址没变,元组中的内容没有变化
print(tuple1,id(tuple1))

# (1, 2, [3.4]) 1769201489536
# (1, 2, [10]) 1769201489536

14.11、面试题

题目一:

def func(list1):
    list1.append(10)
    
my_list = [1,2]
func(my_list)
print(my_list)
# [1,2,10]
def func(list1):
	list1[0] = 10  # 修改的是列表中下标为0位置的数据, 没有修改列表的引用
  
my_list = [1,2]
func(my_list)
print(my_list)
#  [10,2]

题目二:

def func(list):  # list1 =my_list 此时
	list1 = [2,1]  #此时,list变量的引用发生了改变,my_list的引用不会发生改变,数据不变

my_list= [1,2]
func(my_list)
print(my_list)

# [1,2]
1.只有 = 可以改变引用

2.可变类型做参数,在函数内部,如果不使用 = 直接修改形参的引用,对形参进行的数据修改会同步到实参中

题目三:

列表的+=操作

对于列表来说,+=的本质是extend操作
def func(list1)  # list = my_list  引用相同
	list1 += [1,2]  # list1.extend([1,2])  没有直接使用等号改变形参的引用,
                             # 形参的数据改动会影响实参值
   
my_list = ['a','b']
func(my_list)
print(my_list)

# ['a','b',1,2]

14.12、题目四 交换两个变量的值

# 方法一:常规方法 引入第三个变量
a = 10
b = 20

# c = a  # 将变亮a中的值先保存起来 10
# a = b  # 将变量b中的值给a
# b = c  # 将变量c中的值(即最开始a的值)10给b
# print(a, b)

# 方法二:不使用第三个变量,使用数学中的方法
# a = a + b  # a的值30
# b = a - b  # 30-20====>10
# a = a - b  # 30-10====>20
# print(a, b)

# 方法三:重点掌握,python特有
a,b = b,a
print(a,b)


14.13、组包和拆包

组包(pack):将多个而数据值使用逗号连接的过程,组成元组

拆包(unpack):将容器中的数据值使用多个变量分别保存的过程,注意:变量的个数和容器中数据要保持一致

赋值运算符,都是先执行等号右面的代码,执行的结果,保存到左面的变量中
a=10
b=20

# 组包
c = b,a  # 组包
print(type(c),c)
# 输出:<class 'tuple'> (20, 10)

# 拆包
a,b = c
print(a,b)
# 输出:20 10
# 对字典拆包,返回键


# x,y =[1,2,3]  # 错误
x,y,z = [1,2,3]
print(x,y,z)
# 1 2 3

14.14、局部变量和全局变量

变量:根据变量的定义位置,分局部和全局变量

  • 局部变量
局部变量:在函数内部(函数的缩进中)定义的变量,称为是局部变量

特点:  

1.局部变量只能在当前函数内部使用,不能在其他函数和函数外部使用
2.在不同函数中,可以定义名字相同的局部变量,两者只见那没有影响
3.生存周期:(生命周期,作用范围)在函数被调用的时候,局部变量被创建,函数调用结束,局部变量的值被销毁(删除),不能在使用

所以函数中的局部变量的值,如果想要在函数外部使用,需要使用return关键字,将这个值进行返回

def func1():
    num = 10  # num就是局部变量
    print(f'func1 函数中{num}')


def func2():
    num = 100  # 可以在不同函数中定义名字相同的局部变量,没有影响
    print(f"func2 函数中{num}")


# print(num)  # 错误
func1()  # func1 函数中10
func2()
func2
函数中100

  • 全局变量
定义位置:在函数定义的外面,称为全局变量

特点:
1、可以在任何函数中读取(获取)全局变量的值

2、在函数中存在和全局变量名字相同的局部变量,在函数中使用的是 局部变量的值(就近)

3、在函数内部想要修改全局变量的引用,需要使用globle关键字,对变量声明为全局变量

4、生命周期  代码执行时被创建 代码结束时被销毁
global要用就放在第一行
num1 = 10  # 全局变量


def func1():
    print(f"func1 中{num1} ")


def func2():
    num1 =20  #  定义局部变量
    print(f"func2中 {num1}")


def func3():
    global num1   # 这个函数中使用的num1 都是全局变量
    num1 =30     # 修改了全局变量
    print(f"func3 中 {num1}")


func1()  # func1 中10
func2()  # func2中 20
func1()  # func1 中10
func3()  # func3 中 30
func1()  # func1 中30
print(num1)  # 从上到下执行,若没有上面调用结果为 10

14.15、函数返回值进阶

返回值–函数返回多个数据值

函数中想要返回一个数据值,使用return关键字

将 多个数据值组成容器进行返回,一般是元组(组包)
def calc(a,b):
    num = a+ b
    num1 = a-b
    return num,num1


# 写法一
result = calc(10,5)
print(result,result[0],result[1])  #(15, 5) 15 5

#写法二,直接拆包
x,y =calc(20,10)
print(x,y)   # 30 10

14.16、函数参数

形参的不同书写方法

  • 位置传参:

    在函数调用的时候,按照形参的顺序,将实参值传递给形参
    
  • 关键字传参

    在函数调用的时候,指定数据值给到那个形参
    
  • 混合传参

    1.关键字传参必须写在位置传参的后面
    
    2.不要给一个形参传递多个数据值
    
def func(a, b, c):
    print(f"a:{a},b={b},c:{c}")


# 位置传参
func(1, 2, 3)  # a:1,b=2,c:3

# 关键字传参
func(a=2, b=3, c=1)  # a:2,b=3,c:1

# 混合使用
func(1, 3, c=5)  # a:1,b=3,c:5

14.17、缺省参数

缺省参数,默认参数

列表.pop()  # 不写参数,删除最后一个

列表.sort(reverse = True)

1.定义方式
在函数定义的时候,给形参一个默认数据值,这个形参就变为缺省参数,
注意,缺省参数的书写要放在普通参数后面

2.特点(好处)
缺省参数,调用的时候,可以传递实参值,也可以不传递实参值
如果传参,使用的是实参 值,如果不传参,使用的是默认值

可以传参或不传参都可以
def show(name ,sex='保密'):
    print(name,sex)


show('小于')    #小于 保密
show('小于','男')   #小于 男

14.18、多值参数(可变参数/不定长参数)

print(1)
print(1,2)
print(1,2,3)

当书写函数时,不确定参数具体个数时,可以使用不定长参数

  • 不定长位置参数(不定长元组)

    1.在普通参数的前面,加上一个*,这个参数就变为不定长位置参数
    2.特点,这个参数可以接收任意多个 位置 传参的数据
    3.数据类型,形参的类型是 元组
    4.注意,不定长位置参数 要写在普通的参数的后面
    5.一般写法。不定长位置参数的名字为args,即(*args)  # arguments
    
    
  • 不定长关键字参数(不定长字典参数)

    1.书写,在普通参数的前面,加上两个*,这个参数就变为不定长关键字参数
    2.特点,这个形参可以接受任意多个 关键字 传参的数据
    3.数据类型,形参的类型是 字典
    4.注意,不定长关键字参数,要写在所以参数的最后边
    5.一般写法,不定长关键字参数的名字为kwargs,即(**kwargs),keyword arguments
    
  • 完整的参数顺序

    def 函数名(普通函数,*aegs,缺省参数,**kwargs):
    	pass
    	
    # 一般在使用时,使用1-2种,按照这个顺序挑选书写即可
    
def func(*args, **kwargs):
    print(type(args), args)
    print(type(kwargs), kwargs)
    print('-' * 30)


func()  
# <class 'tuple'> ()    
# <class 'dict'> {}

func(1, 2, 3)  # 位置传参,数据都给args
# <class 'tuple'> (1, 2, 3)
# <class 'dict'> {}

func(a=1,b=2,c=4)  # 关键字传参,数据都给kwargs
# <class 'tuple'> ()
# <class 'dict'> {'a': 1, 'b': 2, 'c': 4}

func(1,2,3,a=1,b=3,c=2)
# <class 'tuple'> (1, 2, 3)
# <class 'dict'> {'a': 1, 'b': 3, 'c': 2}

14.19、print说明

print()
# sep='',多个位置参数之间的空格
# end='\n' 每一个print函数结束,都会打印的内容 结束符
print(1, end=' ')  # 不在换行
print(2, end=' ')
print(3, end=' ')
# 输出:1 2 3

print(1, 2, 3, 4, 5, 6, sep='_')
print(1, 2, 3, 4, 5, 6, sep='*_')
# 1 2 3 1_2_3_4_5_6
# 1*_2*_3*_4*_5*_6

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,今天我们来学习Python中的字典(Dictionary)。 字典是一种无序的、可变的数据类型,它以键值对(key-value)的形式存储数据,其中键(key)必须是唯一的,而值(value)可以是任意数据类型。字典用花括号{}表示,每个键值对之间用逗号隔开。 下面是一个简单的字典示例: ``` my_dict = {'name': '张三', 'age': 18, 'gender': '男'} ``` 这个字典中,'name'、'age'、'gender'就是键,而'张三'、18、'男'就是相应的值。 可以使用`dict()`函数来创建一个字典,也可以使用`{}`来创建一个空字典。 接下来,我们来看一些常用的字典操作。 1. 访问字典元素 可以通过键来访问字典中的元素,例如: ``` print(my_dict['name']) # 输出:张三 ``` 如果键不存在,则会抛出KeyError异常。 2. 修改字典元素 可以通过键来修改字典中的元素,例如: ``` my_dict['age'] = 20 print(my_dict) # 输出:{'name': '张三', 'age': 20, 'gender': '男'} ``` 3. 添加字典元素 可以通过键来添加字典中的元素,例如: ``` my_dict['address'] = '北京市' print(my_dict) # 输出:{'name': '张三', 'age': 20, 'gender': '男', 'address': '北京市'} ``` 4. 删除字典元素 可以通过键来删除字典中的元素,例如: ``` del my_dict['gender'] print(my_dict) # 输出:{'name': '张三', 'age': 20, 'address': '北京市'} ``` 5. 字典长度 可以使用`len()`函数来获取字典的长度,例如: ``` print(len(my_dict)) # 输出:3 ``` 6. 字典遍历 可以使用`items()`方法来遍历字典中的每一个键值对,例如: ``` for key, value in my_dict.items(): print(key, value) ``` 输出: ``` name 张三 age 20 address 北京市 ``` 通过上述操作,我们可以初步了解字典的基本用法。在实际应用中,字典是非常重要的数据类型,它可以用来存储和处理各种复杂的数据结构。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值