python 0基础学习笔记4：函数、集合、迭代器、math库、random库

百度云视频链接：https://pan.baidu.com/s/1M4PwNwoy0vZ9KVmSotkLcQ&shfl=sharepset

input函数作用：

从外部获取变量的值
等待输入，阻塞作用，输入的内容保存在变量里。

age = input("请输入年龄：")
print("age=",age)

数字占位符为%d，如果需要显示两位数，则写为%.2d

math库和random库：

返回绝对值：abs()
返回参数最大最小值：max（1,2,3,4） min（1,3,4,5）
求x的y次方：pow（2,5），计算2的5次方。
四舍五入：round（3.46） 保留到整数位；round（3,456,1） 保留一位小数。
即：round（x[,n]）如果给出n值，代表保留到小数点后几位。

利用import 导入一个库。库：封装一些功能。
math是一个数学相关的库

import math

print(math.ceil(18.1))
print(math.floor(18.1))
print(math.modf(18.9))
print(math.sqrt(16))

19 向上取整
18 向下取整
(0.8999999999999986, 18.0) 返回整数部分和小数部分，浮点型的数
4.0 开方

import random

print(random.choice([1,3,5,7,9]))#随机取出列表里面的一个数
print(random.choice(range(5)))#range（5） ==  [0,1,2,3,4]
print(random.choice("sunck"))# “sunck” ==[ “s”,"u","n","c","k"]
print(random.randrange(1,100,2))#从1到100之间随机抽1,3,5,7等等的奇数。
print(random.random())#随机生成 [ 0,1）之间的数。

random.shuffle(list)#将列表的所有元素随机排序
print(random.uniform(3,9))#随机生成一个实数，范围是[3,9]，两头都是包含的

注意：
print(random.randrange([start,]stop[,step])) 至少要传stop这个参数，start指定范围的开始值，包含在范围内。stop指定范围的结束值，不包含在范围内。
step是指定的递增基数，不写的话默认为1。即：从指定范围内，按指定的基数递增的集合中选取一个随机（浮点）数。

set：

类似于dict，是一组key的集合，但不存储value。
本质是无序和无重复元素的集合，可以作为过滤数据用。

创建set：需要一个list或者tuple或者dict作为集合输入。
例如：s1 = set（【1,2,3,4,5，1,2,3】）
s2 = set（(1,2,3,4,5,1,2,3)）
s3 = set（{1:“good”，2:“nice”}）
重复元素在set中会被自动过滤。

添加：s1.add(6)
如果添加的是重复的元素，不会有效果，也不会报错。
但是如果添加的是一个列表，就会报错，因为列表不能作为key，set里面存的相当于是key，所以s1.add（【3】报错。同理字典也不行，因为字典也是可变的。但是s1.add（(2,3）)可以，因为元组不可变。

插入:插入整个list、tuple、字符串，他是打碎插入，分成每个元素插入：
例如：s1.update([6,7,8])
s1.update((6,7,8))#与上面的add区别在与，add是整个元组插入进去作为一个元素，而updata是将元组中每个元素作为一个元素分别插入。
s1.update(“sunck”)

删除：s1.remove()

遍历：for i in s1:

注意set是没有索引的，所以s1【0】会报错，
for index , data in enumerate(s1):print(index,data)
会打印出来编号和元素，但是因为set无序，所以没有什么实际意义。

交集：s1&s2
并集：s1|s2
取完得到的交集并集的类型还是set。

作用：常用于去重，利用类型转换即可。因为list可能有重复，转为set，在转换为list就可以去冗余。即：l = list（set（l））
l1 = 【1,2,3,2,1】
s1 = set（l1）

t2 = （1,2,2,3,1）
s2 = set（t2）

s3 = {1,2,3,4}
l3 = list（s3）变为列表
t3 = tuple（s4）变为元组

迭代器：

可迭代对象：可以直接作用于for循环的对象，英文缩写为
可以用isinstance()去判断一个对象是否是Interable对象。

想用isinstance()，需要引入一个包：

from   collections   import   Iterable
print (isinstance([],Iterable))#True
print (isinstance((),Iterable))#True
print (isinstance({},Iterable))#True
print (isinstance("",Iterable))#True
print (isinstance(( x for x in range(10)),Iterable))#True
print (isinstance(1,Interable))#False

可以直接作用于for循环的数据类型一般分为两种：
1、集合数据类型，如list、tuple、dict、set、string
2、是generator，包括生成器和yield的generator function

迭代器：不但可以作用于for循环，还可以用next（）函数不断调用并返回下一个值，直到最后跑出一个StopInteration错误，表示无法继续返回下一个值。

可以被next（）函数调用并不断返回下一个值的对象称为迭代器（Iterator对象）

可以使用用isinstance()去判断一个对象是否是Interator对象。

from   collections   import   Iterator
print (isinstance([],Iterator))#False
print (isinstance((),Iterator))#False
print (isinstance({},Iterator))#False
print (isinstance("",Iterator))#False
print (isinstance(( x for x in range(10)),Iterator)#True

from collections import Iterator

l = (x for x in range(5))
print(next(l))
print(next(l))
print(next(l))
print(next(l))
print(next(l))

返回：0 1 2 3 4 5

list可以转成iterator对象：a = iter（【1,2,3,4】）
所以：
isinstance（iter（{}），Iterator）#True
isinstance（iter（（）），Iterator）#True
isinstance（iter（“”），Iterator）#True

endstr = "end"
str = ""
for line in iter(input,endstr):
str += line+"\n"
print(str)

运行结果为：输入字符串的换行显示，直到遇到输入为end截止。

函数：

认识函数：在一个完整的项目中，某些功能会反复的使用，就会将功能封装成函数，当我们要使用这个功能的时候直接调用函数。
本质：函数就是对功能的封装。
优点：简化代码结构，增加了代码的复用度（重复使用的程度）；如果想修改某个功能或者修改某个BUG，只需要修改相应的函数即可。

定义函数：

格式：

def 函数名（参数列表）：
语句
return 表达式

其中含义分别是：
def：函数代码块以def开始，def是一个关键字。
函数名：一般遵循标识符规则。
参数列表：参数1，参数2，…，参数n：任何传入函数的参数和变量必须放在圆括号之间，用逗号分隔，函数从函数调用者那里获取的信息。
圆括号（）：是参数列表的起始标志。
冒号：函数内容（封装的功能）以冒号开始，并且缩进。
语句：函数封装的功能。
return：用以结束函数，并返回信息给函数的调用者。
表达式：要返回给调用者的信息。
return 表达式：可以不写，相当于return None。执行完return，函数就结束了，后面的语句不会执行。

调用函数：

格式：

函数名（参数列表）

其中含义分别是：
函数名：时要使用的功能的函数名字。
参数列表;函数调用者给函数传递的信息。如果没有参数，（）也不能省略。

函数调用的本质：实参（本质是值）给形参（本质是变量）赋值的过程。

传递参数：

值传递：传递的不可变类型，如string、tuple、number。
引用传递：传递的可变类型，如list、dict、set。
参数必须按顺序传递，个数要对应。

def func1(num):
num = 10
temp = 20
func1(temp)
print(temp)

结果为 ： 20
#这就是值传递，没有改变为10。

def func1(lis):
lis[0] = 100
li = [1,2,3,4]
func1(li)
print(li)

结果为 ： [100, 2, 3, 4]
#这里把1变成了100，这是引用传递。

a = 10
b = 10
print(id(a),id(b))#两者地址会一样

结果是：8791350948976 8791350948976

a = 10
b = 10
b = 40
print(id(a),id(b))#两者地址会不一样

结果是：8791153423472 8791153424432

相当于又开辟了一块内存，因为数字是不可变的。

关键字参数：

允许函数调用时参数的顺序与定义时不一致。
例如：w = func（s=1，c=2）

默认参数：

调用函数时，如果没有传递参数，则使用默认参数。
例如：
def func（s=1，c=3）

func（）

如果只有一个默认参数：
def func（s，c=2）

func（）

注意：以后用默认参数，最好将默认参数放到最后，否则会按顺序传递参数，导致参数不够。

不定长参数：

能处理比定义时更多的参数。

def func(name,*arr):
print(name)
for x in arr:
print(x)
func("a","b","c","d")

结果为：
a
b
c
d

这里加了 星号（*）的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，他就是一个空元组。
例如：

def mysum(*l):
sum=0
for x in l:
sum+=x
return sum
print(mysum(1,2,3,4,5,6,7,8,9))

结果为：45

另一种方式为：**代表键值对的参数字典，和*所代表的意义类似。
例如：

def func(**kwargs):
print(kwargs)
print(type(kwargs))
func(x=1,y=2,z=3)#这里必须传的是键值的形式，否则会报错。得到的是一个字典。

结果为：
{‘x’: 1, ‘y’: 2, ‘z’: 3}
<class ‘dict’>

还有一种可以表示任何参数的方式：
例如：

def func(*args,**kwargs):
pass#代表一个空语句

匿名函数：

不能用def这样的语句定义函数，使用lambda来创建匿名函数。

特点：
1、lambda只是一个表达式，函数体比def简单。
2、lambda的主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的逻辑。
3、lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间里的参数。
4、lambda虽然是一个表达式，且看起来只能写一行，与C和C++内联函数不同。

格式：
lambda 参数1，参数2，…，参数n ：expression

例如：

sum = lambda num1,num2:num1+num2
print(sum(1,2))

结果为：3

• 点赞
• 收藏
• 分享
• 文章举报

佳佳佳佳佳111 发布了22 篇原创文章 · 获赞 0 · 访问量 96 私信 关注