python学习相关03

有关序列

1.列表，元组和字符串的共同特点

1. 都可以通过索引得到每一个元素，并且索引默认都是从0开始，注意索引也有负数，-1表示倒数第一个元素
2. 可以通过分片的方式得到一定范围内元素的集合
3. 有很多的共同操作符，如重复操作符*，拼接操作符+，关系操作符in/not in
   以上三点统称为序列

2.列表的 内置函数
list() 把一个可迭代对象转换为列表
tuple() 把一个可迭代对象转换为元组
*str() 把参数对象转换为字符串
len(sub) 返回参数sub的长度
max() 返回序列或者参数中的最大值
min（）返回序列或参数中的最小值，要保证序列或参数的数据类型相同
sum（）返回序列和可选参数的总和
sorted() 默认从小到大的排序，作用等同于list.sort()
reversed（）逆向排序，不过返回的是迭代器，可通过list()转换为列表
enumerate() 将列表内元素与其索引值成对组成
zip() 将两个列表打包组成

>>> a= list()
>>> a
[]
>>> b = 'i love bts'
>>> b =list(b)
>>> b
['i', ' ', 'l', 'o', 'v', 'e', ' ', 'b', 't', 's']
>>> c = {1,2,3,4,5,6,11,46,65}
>>> c= list(c)
>>> c
[1, 2, 3, 4, 5, 6, 65, 11, 46]
>>> len(b)
10
>>> max(1,2,3,4,5,)
5
>>> max(b)
'v'
>>> min(c)
1
>>> tuple = {1,2,3,3,4,4,5,6}
>>> max(tuple)
6
>>> tuple2 = {3,1,3,4,5,4}
>>> sum(tuple)
21
>>> numbers = [1,2,3,4,5,6,7,8]
>>> reversed(numbers)
<list_reverseiterator object at 0x00000277A366FE10>
>>> #返回迭代器对象
>>> list(reversed(numbers))
[8, 7, 6, 5, 4, 3, 2, 1]
>>> #转换为列表
>>> 
>>> enumerate(numbers)
<enumerate object at 0x00000277A37255A0>
>>> list(enumerate(numbers))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
>>> a = [1,2,3,4,5,6,7,8]
>>> b = []4,5,6,7,8]
SyntaxError: invalid syntax
>>> b = [4,5,6,7,8]
>>> zip(a,b)
<zip object at 0x00000277A3727DC8>
>>> list(zip(a,b))
[(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]
>>> 

函数

1.函数的定义及定义方法
能够完成某种功能的代码块
使用 def 来定义实现

>>> def myfirstfunction():
	print('这是我创建的第一个函数')
	print('感谢Bilibili....')

	      
>>> myfirstfunction()
	      
这是我创建的第一个函数
感谢Bilibili....

2.函数的参数相关学习
参数分为形参和实参
形参指函数创建和定义过程中小括号内的参数，而实参指的是函数调用时括号内的参数

函数文档
用来解释函数作用，与注释还是有区别的

>>> def myfirstfx(name):
	      '函数定义过程中的name叫做形参'
	      #因为他只是一个形式，表示占据一个参数的位置
	      print('传递进来的'+name+'叫做实参，因为他是具体的参数值')

	      
>>> myfirstfx('suga')
	      
传递进来的suga叫做实参，因为他是具体的参数值

>>> help(myfirstfx)
	      
Help on function myfirstfx in module __main__:

myfirstfx(name)
    函数定义过程中的name叫做形参

关键字参数
让python不根据索引来运行，使用关键字匹配运行，避免了当参数非常多时，可能出现的顺序错误

默认参数
表示定义了默认值的参数

>>> def sayname(name = 'v',words = 'bts'):
	      print(name +'in'+words)

默认参数在运行函数时是可以更改的

>>> sayname('suag')
	      
suaginbts

alt+p 重复上一条语句

收集参数
也可以叫可变参数，有时定义函数时不确定函数需要几个参数
此时，在括号内的参数前加上型号* 即可

>>> def suga(*v):
	print('参数长度是：',len(v))
	print('第二个参数是：',v[1])

		    
>>> suga(1,2,3,4,'jimin')
		    
参数长度是： 5
第二个参数是： 2

如果需要此时要不变的参数，需要在函数定义时，在收集参数后面使用关键字来指出不变的参数

函数与过程

函数是有返回值的，而过程procedure是简单的，特殊并且没有返回值的，返回值是指函数运行过后留下的值
函数变量的作用域问题
局部变量，全局变量

def discounts(price,rate):
    final_price = price*rate
    return final_price

old_price = float(input('请输入原价：'))
rate = float(input('请输入折扣：'))
new_price = discounts(old_price,rate)
print('打折后的价格是：',new_price)

本段代码中的final_price就是一个局部变量，它仅在函数discounts中其作用，出了这个范围就不起作用，在函数中定义的参数及变量都成为局部变量，python在调用这个函数时，使用栈进行存储，当执行完这个给函数后，函数会被自动删除，栈内的数据会被自动清空，函数外是无法访问到内部的局部变量的
全局变量拥有更大的作用域，他们的作用域是整个代码段
如上面代码中的old_price
但是使用全局变量要小心，访问可以，但是试图修改全局变量的话，python会自动创建一个新的全局变量，名称和原来的全局变量一样，此时就会出现意想不到的错误

内嵌函数和闭包

1.global关键字
声明的局部变量变为全局变量，此时Python不进行屏蔽

2.内嵌函数
允许在函数内部创建另一个函数，这个函数称为内嵌函数或内部函数

>>> def fun1():
	print('fun1()正在被调用...')
	def fun2():
		print('fun2()正在被调用')
	fun2()

	
>>> fun1()
fun1()正在被调用...
fun2()正在被调用

在内部函数整个作用域都在外部函数作用域内

3.闭包
函数是编程一个重要的语法结构，闭包是一种编程范式
如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就认为是闭包

>>> def funx(x):
	def funy(y):
		return x*y
	return funy

>>> #对funx来讲，funy就是内部函数
>>> #内部函数funy引用了外面的x，因此funy这个函数就是闭包
>>> #可以理解为要引用外部函数的变量的内部函数
>>> i = funx(8)
>>> i
<function funx.<locals>.funy at 0x000002BD46DCF158>
>>> type(i)
<class 'function'>
>>> i = (5)
>>> i
5
>>> i(5)
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    i(5)
TypeError: 'int' object is not callable
>>> funx(8)(5)
40
>>> 

匿名函数

1.lambda表达式
lambda : ******
冒号前面是原函数的参数，可以是多个，使用逗号隔开即可。冒号后面是函数的返回值

>>> def ds(x):
	return 2*x+1

>>> ds(5)
11
>>> lambda x:2*x+1
<function <lambda> at 0x000002BD46DCF510>
>>> 

使用方法如下

>>> g = lambda x:2*x+1
>>> g(5)
11
>>> 

2.lambda表达式的作用
python写一些脚本时，使用lambda就可以省下定义函数的过程，例如只是需要写一个简单的脚本来管理服务器的时间，我们就不需要专门定义一个函数然后再写调用，使用lambda就可以使得代码更加精简

对于一些抽象并且整个程序执行下来只需要调用一两次的函数，此时给函数起名字比较麻烦，而此时使用lambda表达式就不需要考虑命名的问题

简化代码的可读性

3.两个重要的BIF，内置函数
*filter()*过滤器

>>> list(filter(None,[1,2,3,4,False,True,5]))
[1, 2, 3, 4, True, 5]
>>> #把任何非True的内容过滤掉，前面的None可以自己来定义过滤的方法

一个筛选出奇数的过滤器

>>> def odd(x):
	return x%2

>>> temp = range(10)
>>> show =filter(odd,temp)
>>> list(show)
[1, 3, 5, 7, 9]

使用lambda表达式实现

>>> list(filter(lambda x : x % 2,range(10)))
[1, 3, 5, 7, 9]
>>> 

map（）
在编程领域，map()可以看做映射来解释
将序列的每一个元素作用函数的参数进行运算加工，然后返回所有加工后的元素构成的新序列

>>> list(map(lambda x : x * 2,range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>