Python基础

简介

Python是一种解释型语言，主要包括解释器和函数库。

单词

Help 帮助

Function 函数

Built-in（builtins） 内置

Module 模块

Value 值

Stream 流

Default 默认的

数据分类

列表 list

作用

• 用来表示一系列数据，数据类型可以不同（任意类型），列表内的数据可改变。用中括号定义：list=[]。

• 每个数据间用逗号（英文）分隔开，其中任意一组数据都被称为元素。

• 列表中存储的数据可以通过下标的方式进行获取。

  0   1   2   3   4
['a','b','c','d','e']
 -5  -4  -3  -2  -1

• 列表支持套娃，即可以在列表中存储一个列表，称为二级列表（二维）或多维列表

list = ['a',[11,22,33],'b']
print(list[1])
print(list[1][2])
结果：[11, 22, 33]
	 33

元组 tuple

作用

• 在定义多个数据内容时，可以选择list列表类型，也可以使用tuple元组定义

• 元组和列表都可以存储多个数据（数据类型可以不同）

• 元组用小括号来定义：tuple=()

• 注意，在元组中如果只有一个元素，要在第一个元素后加逗号

  tuple = (1,)

区别

• 列表用[],元组用()

• 元组内的元素不可更改也不能删除，但可以删除整个元组（列表可以）

字典 dict

• 字典也是存储一组或多组数据时使用的，使用大括号分隔：dict={}
• 字典是键值对的存储方式 name：admin
• 键与值必须用冒号分隔，多组键值之间用逗号分隔
• 键名不能重复，值可以重复
• 键名必须用字符串或者数字，值可以是任意类型

实例

获取字典中的值

vard = {'title':'<<鬼谷子>>','author':'鬼谷子','price':'99.99'}
print(vard['author'])
#结果：鬼谷子

键名重复的后果（后面覆盖前面）

vard = {'title':'鬼谷子','author':'鬼谷子','price':'99.99','price':'29.99'}
print(vard['price'])
#结果：29.99

集合 set

• set集合是一个无序且不重复的集合的数据类型(会自动去掉重复的元素)

• set集合用大括号或花括号定义：set = {}或vart=set()

• 定义空集合时必须用set()方法，因为花括号会和字典冲突

• 无法获取结合中的单个元素，但是可以添加和删除

• 集合主要用于运算，交集，差集，并集，对称集合

  a = {1,2,3,'a','b','c'}
  b = {1,'a','b','c'}
  print(a & b)
  print(a - b)
  print(a | b)
  print(a ^ b)
  #{'b', 1, 'a', 'c'}
  #{2, 3}
  #{1, 2, 3, 'b', 'c', 'a'}
  #{2, 3}

set.add

描述

add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

语法

add()方法语法：

set.add(elmnt)

参数

• elmnt – 必需，要添加的元素。

返回值

无。

实例

fruits = {"apple", "banana", "cherry"}
fruits.add("orange") 
print(fruits)
#{'apple', 'banana', 'orange', 'cherry'}

set.discard

描述

discard() 方法用于移除指定的集合元素。

该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

语法

discard() 方法语法：

set.discard(value)

参数

• value – 必需，要移除的元素

返回值

无。

实例

fruits = {"apple", "banana", "cherry"}
fruits.discard("banana") 
print(fruits)
#{'cherry', 'apple'}

数据类型

注意

• 可变数据类型：列表，字典，集合
• 不可变数据类型：字符串，数字，元组
• 容器数据类型：字符串，列表，元组，集合，字典
• 非容器数据类型：数字，布尔类型

基础数据类型转换

什么是数据类型转换？

​ 把一个数据类型转换为另一个数据类型，例如 字符串转为数字（Ascii）

为什么要数据转换？

​ 因为不用数据类型之间不能运算

数据转换的形式？

自动类型转换（向高精度转换）

a = 123
b = True
print(a+b)#bool为true时等于1，false则为0
#124

强制类型转换

• str(字符串)
• int(整型)
• float(浮点型)
• bool(布尔型)
• list(列表)
• tuple(元组)
• dict(字典)
• set(集合)

注意在转换时要看清格式，部分数据类型不一定能转换

a = 'v'
b= int(a)
print(b)
#ValueError: invalid literal for int() with base 10: 'v'

容器数据类型转换

• list(列表)
• tuple(元组)
• dict(字典)
• set(集合)

二进制与位运算

十进制转二进制

• 除2取余，逆序排列

  a = 127
  b = " "
  while a>2:
      c = a % 2
      b += str(c)
      a = a // 2
  b += str(a)
  print(b)
  #1111111

运算符

位运算符	说明	使用形式	描述
&&	按位与按位与	a & ba & b	4 & 5，真为1，假为0
||	按位或按位或描述	a | ba | b实例	4 | 5，有一个为真则为真，否则为假
^^	按位异或按位异或	a ^ ba ^ b	4 ^ 5，相同为0，不同为1
~	按位取反	~a	4，取反，4为0，~-3为1
<<	按位左移	a << b	4 << 2，表示整数 4 按位左移 2 位
>>	按位右移	a >> b	4 >> 2，表示整数 4 按位右移 2

运算符优先级

特点

越小越优

优先级	运算符	描述
1	lambda	Lambda表达式
2	or	布尔“或”
3	and	布尔“与”
4	not x	布尔“非”
5	in，not in	成员测试
6	is，is not	同一性测试
7	<，<=，>，>=，!=，==	比较
8	`	`
9	^	按位异或
10	&	按位与
11	<<，>>	移位
12	+，-	加法与减法
13	*，/，%	乘法、除法与取余
14	+x，-x	正负号
15	~x	按位翻转
16	**	指数
17	x.attribute	属性参考
18	x[index]	下标
19	x[index:index]	寻址段
20	f(arguments...)	函数调用
21	(experession,...)	绑定或元组显示
22	[expression,...]	列表显示
23	{key:datum,...}	字典显示
24	'expression,...'	字符串转换

转义字符

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\	反斜线
'	单引号
"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

模块化编程

模块化编程指把程序进行封装（函数封装，面向对象，文件。。。）

函数

什么是函数?

function->函数，功能

函数就是一个具有特定功能的代码块

函数的作用?

函数就是把代码进行封禁，以提高代码的重要性，提高开发效率，降低后期运维成本

函数的定义和使用 ？

#定义函数【基本结构】
def 函数名([参数列表]):
	当前函数的具体功能的代码
	返回值（可以省略）
---------------------
#函数封装完并不会执行，只是对函数定义
#如果要使用函数，那么要在其他地方调用它（调用必须从主函数开始，因为程序默认只执行主函数）

def love():
    print("hello python")
love()
#hello python

函数的特征和注意

#函数先定义再调用（python要求）
#函数定义后，不调用不执行
#函数的调用没有次数限制
#函数名不要和方法和默认函数冲突，否则会覆盖
#命名规范
	数字字母下划线，不能以数字开头
	严格区分大小写，不能使用关键字
	命名最好有意义，且不要使用中文

函数的参数

函数在定义时，可以再函数列表的位置定义形参

调用带有形参的函数时，需要传递参数（实参）

在调用函数时，按顺序传递实参，实参和形参的数量必须一致，过程就是变量的赋值操作

def love(w):
    print("i love "+w)
a = "python"
love(a)
#i love python

函数的参数类型

• 普通参数，默认参数，收集参数，命名关键字参数，关键字参数收集

普通参数

也就是位置参数，顺序参数，也是必须传递的参数

def love(w,y):
    print("i love "+w+y)
a = "python"
b = ""
love(a,b)
#i love python

默认函数

指在定义形参时默认设置好的参数（变量）

调用时如果没有传递默认参数，那么就会使用默认值

def love(w,y,z=" me"):
    print("i love "+w+y+z)
a = "python"
b = ""
love(a,b)
#i love python me

收集参数

定义一个形参，专门收集多余的实参，或者理解为，不确定需要传递多少个实参，直接用一个形参接收

定义方式为形参前加*号，例：*args[]

多余的参数会存储再args中，类型为元组，即不可改变（元组特性）

def love(w,*z):
    if w == 50:
        print(z)
love(50,100,200,300)
#(100, 200, 300)

命名关键字参数

定义在收集参数后面

关键字参数必须通过形参的名字来进行传递

普通函数也可以通过关键字赋值进行参数传递，这样不要求顺序了

def love(w,*z,m):
    if w == 50:
        print(z)
    print(m)
love(50,100,200,m="hello world")
#(100, 200)
#hello world

关键字参数收集

将多余的关键字收集成字典，类似收集参数

def love(w,*z,**kwargs):
    if w == 50:
        print(z)
    print(kwargs)

love(50,100,200,m="hello world",n="cctv009")
#(100, 200)
#{'m': 'hello world', 'n': 'cctv009'}

注意形参声明的位置

普通参数—>默认参数—>收集参数—>关键字参数—>关键字收集参数

要遵循这个规则，否则会报错，不过极少出现多种参数一起使用的情况

函数的返回值

函数中使用return关键字来返回任意数据或内容，返回位置为调用处

在一个函数中，可以返回一些内容，也可以不返回

若需要返回，又不能直接返回（递归），可以先用默认值（foalt(“INF”),即最大值）占位

return之后的代码不再执行，即return代表函数的结束

函数的分类

1. 执行过程函数：只执行不返回
2. 具有返回值的函数：执行后返回值

变量作用域

作用域就是可以起到作用的范围区域（谁可以用，谁不能用）

表现为变量的有效范围

变量分类

可变数据类型

在函数外定义，函数内可以使用并改变，表现为列表、字典(#`O′)

不可变数据类型

在函数外定义的变量，在函数内只能访问，不能使用进行其他操作，例如元组、集合

全局和局部

全局变量

在函数内外都可以使用的变量

#在函数内使用global关键字定义的变量就是全局变量
#全局变量就是函数内外都能使用

global关键字

描述

在函数内使用，可以访问和改变全局变量

语法

global 关键字语法

global x

实例

# globals 函数返回一个全局变量的字典，包括所有导入的变量。
num = 10
def func():
    love = 20
    global num
    num += love
    print(num)
func()
#30

局部变量

在函数内才能使用的变量

num = 10
def func():
	print(num) #在函数外定义的变量可以访问但不能更改
func()
#10

num = 10
def func():
	num += 10 #在函数内定义的变量函数外不能使用
	print(num)
func()
#TabError: inconsistent use of tabs and spaces in indentation

globals与locals函数

globals：获取全局变量数据（告诉你谁是全局变量）

locals：获取当前变量数据（局部标量）

信息解读

{

‘_name_‘: ‘_main_‘

_doc_‘: 文档说明

#在函数的第一行使用''' '''符，就是__doc__的意思
def outer():
    '''
    这里是让你明白__doc__的作用
    :return:
    '''
    num = 10
    def inner():
        nonlocal num
        num += 1
        print(num)
    inner()
outer()
print(outer.__doc__)
#11

   # 这里是让你明白__doc__的作用
   # :return:

‘_package_‘: 包

‘_loader_‘: 加载程序

‘_spec_‘: 规范

‘_annotations_‘: {注释},

‘_builtins_‘: <内置命令>,

‘_file_‘: 文件路径

‘__cached__':缓存

‘outer’: <函数位置>

函数的作用域

变量和函数都有作用域

def outer():
    print("hello")
    #在函数内定义的函数不能直接被调用
    def inner():
        print("world")
outer()
#也就是不能再这里直接inner()
#hello

nonlocal关键字

解决问题：怎么在内函数中调用外函数的局部变量

使用global会报错，因为num不是全局变量，而是局部变量

def outer():
    num = 10
    def inner():
        global num
        num += 1
        print(num)
    inner()
outer()
#NameError: name 'num' is not defined：这是局部变量

使用nonlocal关键字

def outer():
    num = 10
    def inner():
        nonlocal num
        num += 1
        print(num)
    inner()
outer() #ps:使用nonlocal关键字时上一层必须存在该变量，不能提升为全局变量
#11 #可以了，问题解决啦

函数练习题

#九九乘法表
#def jiujiu(n=0):
    '''
    功能：打印九九乘法表
    n = 0(默认)：正向输出
    n = 1：反向输出
    '''
#   if n ==0:
#       rg = range(1,10)
#   else:
#       rg = range(9,0,-1)#
#   for x in rg:
#       for y in range(1,x+1):
#           print(f'{x}x{y}={x*y}',end=" ")
#       print()
#jiujiu(1)

函数递归

递归函数就是定义了一个函数，然后再函数内，自己调用了自己这个函数

递归必须有结束，不然就会栈溢出，也可以理解为死循环

递归函数是一层层的进入，染后一层层的返回

递归中的值在被调用的时候会根据条件改变，但实际是不变的

递归函数的效率并不高，能不用就不用（使用for循环代替）

因为递归函数运行时会不断开闭栈空间，直到运算结束才会释放空间

问题

斐波那契数列

1，1，2，3，5，8，13。。。

#list[0]*1000:即初始化1000个为0的单链表
n = int(input())
list = [0]*(n+1)
list[0]=1
list[1]=1
def feibo(n,v=2):
    if n > 1:
        list[v] = list[v - 1] + list[v - 2]
        feibo(n - 1, v + 1)
    return list[n-1]
print(feibo(n))
#老师写的。。。
n = int(input())

def feibo(n):
    if n < 3: #1,2位为1
        return 1
    else:
        return feibo(n-1)+feibo(n-2)
print(feibo(n))
#递归函数是从高层一层层向下去计算的，值是以if返回的1从底层一层层返回的

实现阶乘

1*2*3*4*5*6*7

n = int(input())
def jiecheng(n):
    if n == 1:
        return 1
    else:
        return n*jiecheng(n-1)
print(jiecheng(n))
'''
    7*jiecheng(6)
        6*jiecheng(5)
            5*jiecheng(4)
                4*jiecheng(3)
                    3*jiecheng(2)
                        2*jiecheng(1)
                            jiecheng(1) ==> 1
                        2*1 ==> 2
                    3*2 ==> 6
                4*6 ==> 24
            5*24 ==> 120
        6*120 ==> 720
    7*720 ==> 5040
'''

高阶函数（自定义）

回调函数

把函数作为一个参数传递给另一个函数，就叫回调函数，也叫函数嵌套

如果函数中传递的参数是一个函数，并且在函数中使用了传递进来的函数，那么这个函数就称为一个回调函数

实列演示

def func(f):
    f() #f已称为函数
def love():
    print(123)
func(love)
#123
#个人感觉回调函数就是函数嵌套，作用就像多个for循环，学会蛮有用的

闭包函数

它跟回调函数有点像，它是返回一个函数作为它的返回值

在一个函数内返回一个内函数，并且这个内函数还使用了外函数中的局部变量，者就是闭包函数

实列演示

# 闭包函数
def func():
    money = 0
    def work():	#在外函数中定义内函数
        nonlocal money
        money += 100
    def overtime():
        nonlocal  money
        money += 200
    def buy():
        nonlocal  money
        money -= 50
    return work() #调用了work函数，实现情况可以加判断条件
func()
func()
func()
#100
100
100

特点

1. 在外部函数调用变量，并且在内部函数中使用了这个局部变量
2. 在外函数中 符号了内函数，返回的内函数就是闭包函数
3. 主要在于保护了外函数中的局部变量，即可以被使用，又不会被破坏

检测闭包函数

• 函数：__closure__
• 作用：检测是否为闭包函数
• 输出：None（不是），cell（是）

匿名函数（lambda）

匿名函数就是可以不用定义，并且函数也不存在名字

在python可以使用lambda表达式定义匿名函数

注意lambda仅仅只是一个表达式，不是一个代码块，所以又叫一行代码的函数

lambda表达式也有形参，并且不能访问除自己形参外的任何数据

语法

lambda [参数]:expression

冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式（只能为一个）。其实lambda返回值是一个函数的地址，也就是函数对象。

实例

sum = lambda x,y:x+y
print(sum(11,22))#此时sum作为函数名使用
#33 #不能做过于复杂的操作
res = lambda sec:"很man" if sec=='男' else "很nice"
print(res('女'))
#很nice

作用

做一些简单的操作，又不想定义函数时用

迭代器

• 迭代器时python特色功能之一，是访问集合元素的一种方式

• 迭代器是一个可以记住访问遍历的位置的对象

• 迭代器只能从前往后一个一个遍历，不能后退

• 从集合的第一个元素开始访问，直到所有函数都被访问完

总结

能被next()函数调用，并不对返回下一个值的对象称为迭代器（inter）

Pyhton iter()方法

作用

把可迭代对象转为迭代器对象

参数

可迭代对象（str、list、tuple、dict、set、range。。。）

返回值

迭代器对象

实例

f4 = ['诸葛亮','司马懿','周瑜','元歌']
res = iter(f4)
r=next(res)
print(r)
r=next(res)
print(r)
r=next(res)
print(r)
r=next(res)
print(r)
r=next(res)
print(r)
#诸葛亮
司马懿
周瑜
元歌
StopIteration#5次就超出可迭代范围了
#迭代器取值的方案

Pyhton next()方法

功能

调用迭代器，返回迭代器中的数据

参数

可迭代对象，即iter()后的数据

实例

1.使用next()函数调用迭代器对象（就是被iter()了的变量）
print(next(res))
print(next(res))
2.使用list取值
r = list(res)
print(r)
3.使用for循环
for i in res:
	print(i)

特点

1. 调用一次减少一次,直至取完值后报错
2. list一次就能取完
3. 使用for循环

补充

type()#检测类型
isinstance(参数,Iterator)#检测是否为迭代的对象

内置函数

Pyhton range()函数

功能

生成一个指定的数字序列数字序列，一般用于for循环

语法

range(start, stop[, step])

参数

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

返回值

• 可迭代的对象，数字序列

实例

1.print(list(range(5)))#转为列表数据
#[0, 1, 2, 3, 4]
2.for i in range(5):#通过for循环遍历
    print(i,end=" ")
#0 1 2 3 4 
3.res = range(5)#转为迭代器，使用next函数调用
res = iter(res)
print(next(res))
print(next(res))
#0
#1

什么是左闭右开

• 左闭右开是一种区间表示方式，例如在整数上[3,6)表示3，4，5三个数，闭代表取值取到那个数，开代表取值取不到那个数。

• range函数：步长为正，左闭右开；步长为负，左开右闭。

print(list(range(5,0,-1)))
#[5, 4, 3, 2, 1]
ps:这里补充一点，用负数时要注意start>stop

Python zip()函数

功能

#函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
#如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
总结：将元素以元组的方式打包成迭代器对象，以列表形式返回

语法

zip([iterable, ...])

参数

• iterabl – 一个或多个迭代器

返回值

• 返回元组列表

实例

var1='1234'
var2=['a','b','c']
var3=('A','B','C')
res = zip(var1,var2,var3)
pint(res) #返回迭代器对象
print(list(res))
#[('1', 'a', 'A'), ('2', 'b', 'B'), ('3', 'c', 'C')]
#返回的最短的组合
#看代码就知道了
提取方法
1.list()
print(list(res))
2.next()
print(next(res))

扩展语法

zip()与_*_号运算符结合可以用来拆解一个列表

x = [1,2,3]
y = [4,5,6]
zipped = zip(x,y)
print(list(zipped))
x2,y2 = zip(*zip(x,y))
print(x2,y2)
print(*zip(x,y)) #(1, 4), (2, 5), (3, 6)
#[(1, 4), (2, 5), (3, 6)]
(1, 2, 3) (4, 5, 6)

数据类型相关内置函数

• int()
• float()
• bool()
• complex()
• str()
• list()
• tuple()
• dict()
• set()

变量相关函数

• id() 获取当前数据标识
• type() 获取当前数据的类型
• print() 打印输出
• input() 获取输入
• isinstance() 检测是否为指定的数据类型

数学相关函数

• abs() 返回绝对值 print(abs(-9))#9
• sum() 求和 print(sum([1,2,3,4,5]))#15
• max() 最大值 print(max([1,2,3,4,5]))\print(max(1,2,3,4,5))#5
• min() 最小值 print(min([1,2,3,4,5]))#1
• pow 幂运算
• round 四舍五入

round函数的特殊情况
奇进偶退
print(round(7.5))
print(round(6.5))
print(round(7.4))
print(round(6.4))
print(round(6.6))
print(round(7.6))
8	#对比第一第二个发现了什么嘛
6	
7	#看出来它只对.5情况生效
6
7	#没写补上，0.5和-0.5的情况下都为0
8

进制相关函数

• bin() 转为二进制
• int() 整型，十进制（在二进制前+0b同样可以实现转为10进制）
• oct() 转为八进制
• hex() 转为十六进制
• ord() 将Ascii字符转为数字print(ord('A'))#65
• chr() 将数字转为Ascii码print(chr(65))#A

补充

使用字符串截取形式去点前2个字符
print(bin(123)[2:])
#1111011	#其他同理

高阶函数

Pyhton sorted()函数

功能

• 排序

语法

sorted(iterable, cmp=None, key=None, reverse=False)

参数

• iterable – 可迭代对象。
• cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值

返回重新排序的列表。

实例

1.arr = [-4,-2,3]
res = sorted(arr,key=abs)#会警告但不报错
print(res)
#[-2, 3, -4]	#以绝对值为例排序，但不变为绝对值（我一直以为会变成绝对值）
2. func(num):	#定义自定义排序方式
    print(num,num%2)
    return num% 2
arr = [3,2,4,6,5,7,9]
res = sorted(arr,key=func)
print(res)
#6 0
5 1
7 1
9 1
[2, 4, 6, 3, 5, 7, 9]
3.arr = [3,2,4,6,5,7,9]
res = sorted(arr,key=lambda x:x%2)#用匿名函数
print(res
#[2, 4, 6, 3, 5, 7, 9]

Python map()函数

功能

对传入的可迭代数据中的每个元素进行处理，返回一个新的迭代器

参数

• function – 函数
• iterable – 一个或多个序列

返回值

• Python 2.x 返回列表。

• Python 3.x 返回迭代器

实例

#把一个字符串数字的列表转为整型的数字列表
#1.普通方法
varlist = ['1','2','3','4','5']
newlist = []
for i in varlist:
    newlist.append(int(i))
print(newlist)
#[1, 2, 3, 4, 5]
#2.使用map函数进行处理
varlist = ['1','2','3','4','5']
res = map(int,varlist)
print(list(res))
#[1, 2, 3, 4, 5]
#[1,2,3,4] ==> [1,4,9,16]
#1.普通方法
varlist = [1,2,3,4]
newlist = []
for i in varlist:
    newlist.append(i**2)
print(newlist)
#[1, 4, 9, 16]
#2.使用map函数
varlist = [1,2,3,4]
res = map(lambda x:x**2,varlist)
#[1, 4, 9, 16]

作业

['a','b','c','d'] --> [65,66,67,68]
varlist = ['a','b','c','d']
res = map(lambda x:ord(x)-32,varlist)
print(list(res))
#[65, 66, 67, 68]

Pyhton reduce()函数

描述

reduce() 函数会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

注意：Python3.x reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：

from functools import reduce

语法

reduce() 函数语法：

reduce(function, iterable[, initializer])

参数

• function – 函数，有两个参数
• iterable – 可迭代的数据对象（元组，列表）
• initializer – 可选，初始参数

返回值

返回函数计算结果。

实例

from functools import reduce
varlist = [5,2,3,1]
res = reduce(lambda x,y:x*y,varlist)
print(res)
#等于5*2*3*1=30
'456'-->456
def func(x):
    vard = {'0':0,'1':1,'2':2,'4':4,'5':5,'6':6}
    return vard[x]
iter1 = map(func,'456')
iter2 = reduce(lambda x,y:x*10+y,iter1)
print(iter2)
#456

Pyhton filter()函数

描述

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

注意: Python2.7 返回列表，Python3.x 返回迭代器对象。

功能

• 过滤数据，把元素拿到函数中进行处理，返回True则保留，反之丢弃

语法

以下是 filter() 方法的语法:

filter(function, iterable)

参数

• function – 判断函数。
• iterable – 可迭代对象。

返回值

返回列表。

---

实例

var = range(1,10)
it = filter(lambda n:True if n % 2 == 0 else False,var)
print(list(it))
#[2, 4, 6, 8]

详解字符串

定义方式

1.var = ''
2.var = ""
3.var = ''''''

嵌套

var = '"gg","cc","cc"'

转义字符

描述

一个普通字符在转义符’'的后面，实现宁外一种意义

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\	反斜线
'	单引号
"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

相关操作

操作	描述
+，’a’+’b’=’ab’	将两个字符串拼接成一个字符串，中间不隔开
*，’a’*5=’aaaaa’	把字符串重复*次，中间不隔开
切片，str[开始值:结束值:步进值]	正数0开始，倒数-1开始，中间用冒号隔开，默认步进1，不写获取所有

切片

## var = 'abcdefghijklmnopqrstuvwxyz'
# print(var[2])#获取指定下标值
# print(var[2:5])#从2开始，至5结束，不包括5
# print(var[4:8:2])#间隔为2，意为每隔1个取一个
# print(var[::])#从头取到尾，即默认
# print(var[::2])#隔一个取一个
# print(var[::-1])#字符串倒过来
# print(var[::-2])#倒过来，隔一个取一个
c
cde
eg
abcdefghijklmnopqrstuvwxyz
acegikmoqsuwy
zyxwvutsrqponmlkjihgfedcba
zxvtrpnljhfdb

字符串格式化

format()

1.普通方式
a = '床前'
var = '{}明月光'.format(a)
2.索引传参
a = '上光'
b = '床前'
var = '{1}明月光，疑是地{0}'.format(a,b)
print(var)
#床前明月光，疑是地上光
3.关键字传参
var = '{}明月光'.format(a='床前')
4.容器类型数据传参
rlist = ['上光','床前']
var = '{1}明月光，疑是地{0}'.format(*rlist)
print(var)
#床前明月光，疑是地上光
#注意容器下标还有'*'号（用于取值，没有会报错），字典（**）
5.f方法
#f是format的缩写
my_list = ['菜鸟教程', 'www.runoob.com']
print(f"网站名：{my_list[0]}, 地址 {my_list[1]}") 
#网站名：菜鸟教程, 地址 www.runoob.com
6.限定小数点
var = '圆周率是多少：{:.2f}'.format(3.1415926)
print(var)
#圆周率是多少：3.14

字符串函数

字符大小写相关函数

Python capitalize()方法

描述

Python capitalize() 将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。

语法

capitalize()方法语法：

str.capitalize()

参数

• 无。

返回值

该方法返回一个首字母大写的字符串。

实例

var = 'hello world'
var = 'hello world'
var = var.capitalize()
print(var)
#Hello world

Python title()方法

描述

Python title() 方法返回”标题化”的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。

语法

title()方法语法：

str.title();

参数

• NA。

返回值

返回”标题化”的字符串,就是说所有单词都是以大写开始。

实例

var = 'hello world'
var = var.title()
print(var)
#Hello World

Python upper()方法

描述

Python upper() 方法将字符串中的小写字母转为大写字母。

语法

upper()方法语法：

str.upper()

参数

• NA。

返回值

返回小写字母转为大写字母的字符串。

实例

var = 'hello world'
var = var.upper()
print(var)
#HELLO WORLD

Python lower()方法

描述

Python lower() 方法转换字符串中所有大写字符为小写。

语法

lower()方法语法：

str.lower()

参数

• 无。

返回值

返回将字符串中所有大写字符转换为小写后生成的字符串。

实例

var = 'HELLO WORLD'
var = var.lower()
print(var)
#hello world

Python swapcase()方法

描述

Python swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。

语法

swapcase() 方法语法：

str.swapcase();

参数

• NA。

返回值

返回大小写字母转换后生成的新字符串。

实例

var = 'hEllO wORLD'
var = var.swapcase()
print(var)
#HeLLo World

字符检测相关函数

Python isupper()方法

描述

Python isupper() 方法检测字符串中所有的字母是否都为大写。

语法

isupper()方法语法：

str.isupper()

参数

• 无。

返回值

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

实例

var = 'HELLO WORLD'
var = var.isupper()
print(var)
#True #反之则为Flase，不检测中文、空格等其他符号

Python islower()方法

描述

Python islower() 方法检测字符串是否由小写字母组成。

语法

islower()方法语法：

str.islower()

参数

• 无。

返回值

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

实例

var = 'HELLO WORLD'
var = var.islower()
print(var)
#False #与上面那个方法类似，检测是否为全小写

Python isalnum()方法

描述

Python isalnum() 方法检测字符串是否由字母和数字组成。

语法

isalnum()方法语法：

str.isalnum()

参数

• 无。

返回值

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

实例

var = 'wo爱ni1314'
var = var.isalnum()
print(var)
#True #其实还包括中文，但是官方解释如此，出现这三种外的字符（包括空格）直接Flase

Python isalpha()方法

描述

Python isalpha() 方法检测字符串是否只由字母组成。

语法

isalpha()方法语法：

str.isalpha()

参数

• 无。

返回值

如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。

实例

var = 'iloveyou一生一世'
var = var.isalpha()
print(var)
#True

Python isdigit()方法

描述

Python isdigit() 方法检测字符串是否只由数字组成。

语法

isdigit()方法语法：

str.isdigit()

参数

• 无。

返回值

如果字符串只包含数字则返回 True 否则返回 False。

实例

var = '5201314'
var = var.isdigit()
print(var)
#True

Python isspace()方法

描述

Python isspace() 方法检测字符串是否只由空格组成。

语法

isspace()方法语法：

str.isspace()

参数

• 无。

返回值

如果字符串中只包含空格，则返回 True，否则返回 False.

实例

var = ' \t\n'
for i in var:
    print(i.isspace())
#True
#True
#True
#tab,空格，换行都为True

Python startswith()方法

描述

Python startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

语法

startswith()方法语法：

str.startswith(str, beg=0,end=len(string));

参数

• str – 检测的字符串。
• strbeg – 可选参数用于设置字符串检测的起始位置。
• strend – 可选参数用于设置字符串检测的结束位置。

返回值

如果检测到字符串则返回True，否则返回False。

实例

var = 'Hello World'
res = var.startswith('H')
print(res)
#True
var = 'Hello World'
res = var.startswith('H',1)
print(res)
#Flase
#一般不必要指定结束的位置，可以判断多个，这里只写了一个

Python endswith()方法

描述

Python endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数”start”与”end”为检索字符串的开始与结束位置。

语法

endswith()方法语法：

str.endswith(suffix[, start[, end]])

参数

• suffix – 该参数可以是一个字符串或者是一个元素。
• start – 字符串中的开始位置。
• end – 字符中结束位置。

返回值

如果字符串含有指定的后缀返回True，否则返回False。

实例

var = 'Hello World'
res = var.endswith('World')
print(res)
#True 

字符串查找相关函数（重点）

var = 'iloveyou'
@检测一个字符串是否存在另一个字符串中
res = 'love' in var
#True
@获取字符串的长度
res = len(var)
#8
@获取指定字符在字符串中的索引位置，未找到则返回-1
res = var.find('you') 
#5 #返回首字母的索引位置
res = var.find('you',0,4)
#-1 #可以指定开始和结束的索引位置
@从右边开始找
res = var.rfind('you')
@str.index()与find类似，如果没有找到则报错
res = var.index('you')
#5
@同样也有个rindex(),就不多说了
@计算字符出现的次数并返回统计出来
var = 'Hello World'
print(var.count('H'))
#1

作业

单词全背，各敲三遍

字符串操作相关函数(重点)

Python split()方法

描述

Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

语法

split() 方法语法：

str.split(str="", num=string.count(str)).

参数

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num – 分割次数。默认为 -1, 即分隔所有。

返回值

返回分割后的字符串列表。

实例

@普通方法
var = 'i,love,you,you,you'
res = var.split(',',-1)
print(res)
#['i', 'love', 'you', 'you', 'you']
#要注意的是，split是以什么什么分割字符串，指定的字符最好有序可言
@按照指定的字符分割，把一个字符串分割成一个列表
var = 'user_admin_id_123'
res = var.split('_')
print(res)
#['user', 'admin', 'id', '123']
@有多个分割字符时
var = 'user_admin_id_123'
vars = 'uid=123&type=ad&key=by'
res = vars.split('&')
for i in res:
    r = i.split('=')
    print(r.pop())#pop是列表中的移除方法，默认移除末尾元素，
print(res)
#123
#ad
#by
#['uid=123', 'type=ad', 'key=by']
@可以指定分割的次数
var = 'user_admin_id_123'
res = var.split('_',2)
print(res)
#['user', 'admin', 'id_123']
@rspilt,不加次数与spilt相同，加了就是从右边开始
res = var.rsplit('_',2)
print(res)
#['user_admin', 'id', '123']

Python join()方法

描述

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

语法

join()方法语法：

str.join(sequence)

参数

• sequence – 要连接的元素序列。

返回值

返回通过指定字符连接序列中元素后生成的新字符串。

实例

@按照指定的字符串，吧容器类型中的数据链接成一个字符串
arr = ['user','admin','id','123']
res = '%'.join(arr)
print(res)
#user%admin%id%123

Python strip()方法

描述

Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

语法

strip()方法语法：

str.strip([chars]);

参数

• chars – 移除字符串头尾指定的字符序列。

返回值

返回移除字符串头尾指定的字符生成的新字符串。

实例

var = '     abc     '
res = var.strip(' ')
print(res)
#abc
@lstrip,去除左侧的指定字符
@rstrip,去除右侧的指定字符

Python replace()方法

描述

Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

语法

replace()方法语法：

str.replace(old, new[, max])

参数

• old – 将被替换的子字符串。
• new – 新字符串，用于替换old子字符串。
• max – 可选字符串, 替换不超过 max 次

返回值

返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

实例

var = 'iloveyouyouyou'
res = var.replace('you','Ironman',1)#1指替换次数
print(res)
#iloveIronmanyouyou

Python center()方法

描述

Python center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。

语法

center()方法语法：

str.center(width[, fillchar])

参数

• width – 字符串的总宽度。
• fillchar – 填充字符。

返回值

该方法返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。

实例

var = 'iloveyou'
res = var.center(12,'@')
print(res)
#@@iloveyou@@
#整体为12各字符，不够的在两边加上

补充

rjust&&ljust
rjust:整体为12个，不够的在左边补上
var = 'iloveyou'
res = var.rjust(12,'@')
print(res)
#@@@@iloveyou #对，你没看错，它说的是你本来的字符串在右边
ljust:整体为12个，不够的在右边补上
var = 'iloveyou'
res = var.ljust(12,'@')
print(res)
#iloveyou@@@@

作业

出来了解的后面3个，其他手敲三遍

数据类型详解-列表

• 就是一组有序数据组合，列表中的数据可以被修改

列表的定义与基本操作

• 使用中括号[]定义
• 也可以使用list函数定义
• 列表中的元素用逗号分割
• 列表中的元素可以是任意类型

基本操作

拼接

var1 = [1,2,3,4]
var2 = ['a','v','b']
res = var1 + var2 +[11,22,33]
print(res)
#[1, 2, 3, 4, 'a', 'v', 'b', 11, 22, 33]
#别管警告，不错就行

重复

res = ['a','b','c'] *3
print(res)
#['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

检测

res ='a' in ['a','b','c']
print(res)
#True

索引

'''
 0   1   2   3
'a' 'b' 'c' 'd'
-4  -3  -2  -1
'''
#print()

索引获取、修改、添加

获取
var = ['a','b','c','d']
res = var[1]
res = var[-3]
print(res)
#b
修改
var = ['a','b','c','d']
var[1] = 'x'
print(var)
#['a', 'x', 'c', 'd']
添加
@注意：不能通过下标添加元素，否则会报错
var = ['a','b','c','d']
var[4]='ff'
print(var)
IndexError: list assignment index out of range
@正常用法
var = ['a','b','c','d']
var.append('ff')
print(var)
#['a', 'b', 'c', 'd', 'ff']
@不能指定下标添加，否则同样会报错
var = ['a','b','c','d']
var[4].append('c')
print(var)
IndexError: list assignment index out of range

长度

var = ['a','b','c','d']
res = len(var)
print(res)
#4

定义长列表

作用：不报超出分为的错，可以在定义长度内任意修改、添加元素
var = [0] * 10
print(var)
print(len(var))
#[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
#10
var = [0] * 10
var[4]='a'
# var[7].append(3)
print(var)
print(len(var))
#[0, 0, 0, 0, 'a', 0, 0, 0, 0, 0]
#10
#但不能用append()
@有趣的方式
a = [1]
print(a)
for i in range(2,10):
    a.append(i)
print(a)
del a[8]
print(a)
#[1]
#[1, 2, 3, 4, 5, 6, 7, 8, 9]
#[1, 2, 3, 4, 5, 6, 7, 8]

删除

@del
var =[1,2,3,4]
del var[2]	#指定下标删除
print(var)
del var	#不指定删除所有
print(var)
#[1, 2, 4]
#    print(var)
#NameError: name 'var' is not defined

移除

@pop，列表专属方法，至少字符串没这个福分
作用：移除末尾或指定下标的元素
var = [1,2,3,4]
var.pop()
print(var)
var.pop(0)
print(var)
[1, 2, 3]
[2, 3]
补：跟删除的区别就是它不能干掉列表

列表中的切片

切片操作

语法

• list[0:-1:1]，默认情况

var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
vlist = var + f4
print(vlist[2:])	#从第三个开始
print(vlist[:2])	#到第三个前结束
print(vlist[2:6])	#从第三个到第五个
print(vlist[2:6:2])	#步进为2
print(vlist[::-1])	#倒序输出，注意哦，是[::-1]哦
['黎明', '郭富城', '小沈阳', '刘能', '宋小宝', '赵四']
['刘德华', '张学友']
['黎明', '郭富城', '小沈阳', '刘能']
['黎明', '小沈阳']
['赵四', '宋小宝', '刘能', '小沈阳', '郭富城', '黎明', '张学友', '刘德华']

更新与删除

@通过切片更新
var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
vlist = var + f4
print(vlist)
vlist[2:6] = 'a'	#这一步是2到5的空间变成'a'了，
print(vlist)
print(len(vlist))
vlist[2:6] = 'abc'	#这一步是2到5编程'a'了，6，7变成'b','c'
print(vlist)
#['刘德华', '张学友', '黎明', '郭富城', '小沈阳', '刘能', '宋小宝', '赵四']
#['刘德华', '张学友', 'a', '宋小宝', '赵四']
#5
#['刘德华', '张学友', 'a', 'b', 'c']
#使用列表进行[2:6]='a'类似的情况时，'a'占掉2到5的空间，并只存在一个
#从指定下标开始，到指定下标结束，并替换为对应的数据，容器类型会拆分元素进行赋值

补充

@再讲一下
var  = [0] * 10
var[:] = 'a'
var[5] = 'b'
print(var)
#IndexError: list assignment index out of range
#很显然，我们定义了10个空间，但是报错说超出范围，只有可能是空间被占掉了

列表相关函数

Python List len()方法

描述

len() 方法返回列表元素个数。

语法

len()方法语法：

len(list)

参数

• list – 要计算元素个数的列表。

返回值

• 返回列表元素个数

实例

var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
vlist = var + f4
var = vlist
print(len(var))
#8

Python List append()方法

描述

append() 方法用于在列表末尾添加新的对象。

语法

append()方法语法：

list.append(obj)

参数

• obj – 添加到列表末尾的对象。

返回值

该方法无返回值，但是会修改原来的列表。

实例

n = 2
list=[]
list.append(n)
print(list)
结果：[2]

Python List count()方法

描述

Python count() 方法用于统计字符串里某个字符或子字符串出现的次数。可选参数为在字符串搜索的开始与结束位置。

语法

count()方法语法：

str.count(sub, start= 0,end=len(string))

参数

• sub – 搜索的子字符串
• start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值

该方法返回子字符串在字符串中出现的次数。

实例

str="hello world"
n = "o"
print(str.count(n,2,5))
结果：1

Python List extend()方法

描述

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

语法

extend()方法语法：

list.extend(seq)

参数

• seq – 元素列表。

返回值

该方法没有返回值，但会在已存在的列表中添加新的列表内容。

实例

var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
var.extend(f4)
print(var)
#['刘德华', '张学友', '黎明', '郭富城', '小沈阳', '刘能', '宋小宝', '赵四']
#跟'+'号的作用差不多，而且extend()括号中放入的是容器，也就是列表

Python List index()方法

描述

Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

语法

index()方法语法：

str.index(str, beg=0, end=len(string))

参数

• str – 指定检索的字符串
• beg – 开始索引，默认为0。
• end – 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则抛出异常。

实例

vlist = ['a','b','c','a','b','c']
res = vlist.index('a')
print(res)
#0
#只找第一次发现的，后面的不管
vlist = ['a','b','c','a','b','c']
res = vlist.index('a',2,-1)
print(res)
#3
#也可以指定查找范围

Python List insert()方法

描述

insert() 函数用于将指定对象插入列表的指定位置。

语法

insert()方法语法：

list.insert(index, obj)

参数

• index – 对象 obj 需要插入的索引位置。
• obj – 要插入列表中的对象。

返回值

该方法没有返回值，但会在列表指定位置插入对象。

实例

var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
vlist = var + f4
vlist.insert(-1,'张国荣')	#指定-1位置时会把原来-1位置的元素往后挤
print(vlist)
#['刘德华', '张学友', '黎明', '郭富城', '小沈阳', '刘能', '宋小宝', '张国荣', '赵四']
@于是，你就知道了insert方法是可以出栈的
var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
vlist = var + f4
vlist.insert(8,'张国荣')
print(vlist)
#['刘德华', '张学友', '黎明', '郭富城', '小沈阳', '刘能', '宋小宝', '赵四', '张国荣']
#有问题吗，没有问题。

Python List pop()方法

描述

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

语法

pop()方法语法：

list.pop([index=-1])

参数

• obj – 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

返回值

该方法返回从列表中移除的元素对象。

实例

var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
vlist = var + f4
kik = vlist.pop()
res = vlist.pop(5)
print(kik)
print(res)
print(vlist)
#赵四
#刘能
#['刘德华', '张学友', '黎明', '郭富城', '小沈阳', '宋小宝']
#被pop的元素会从列表中出栈（区别），所以非必要不要用

Python List remove()方法

描述

remove() 函数用于移除列表中某个值的第一个匹配项。

语法

remove()方法语法：

list.remove(obj)

参数

• obj – 列表中要移除的对象。

返回值

该方法没有返回值但是会移除列表中的某个值的第一个匹配项。

实例

vlist = ['a','b','c','a','b','c']
vlist.remove('a')
print(vlist)
#['b', 'c', 'a', 'b', 'c']
#删除了，但是只删除一个，不能默认，如果没有指定的元素就报错

Python3 List clear()方法

描述

clear() 函数用于清空列表，类似于 **del a[:]**。

语法

clear()方法语法：

list.clear()

参数

• 无。

返回值

该方法没有返回值。

实例

var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
var.clear()
print(var)
#[]
#就是清空列表，相当于del list

Pyhton List reverse()方法

描述

reverse() 函数用于反向列表中元素。

语法

reverse()方法语法：

list.reverse()

参数

• no

返回值

该方法没有返回值，但是会对列表的元素进行反向排序。

实例

var = ['刘德华','张学友','黎明','郭富城']
f4 = ['小沈阳','刘能','宋小宝','赵四']
var.extend(f4)
var.reverse()
print(var)
#['赵四', '宋小宝', '刘能', '小沈阳', '郭富城', '黎明', '张学友', '刘德华']

Pyhton List sort()方法

描述

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

使用list.sort()方法来排序，此时list本身将被修改。通常此方法不如sorted()方便，但是如果你不需要保留原来的list，此方法将更有效。

list.sort()方法仅被定义在list中，相反地sorted()方法对所有的可迭代序列都有效。

语法

sort()方法语法：

list.sort(cmp=None, key=None, reverse=False)

参数

• cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序（排序方法）。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序（根据谁来排序）。
• reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

返回值

该方法没有返回值，但是会对列表的对象进行排序。

实例

var = [2,4,2,3,4,4,5,43,78,9,2,2]
var.sort()
print(var)
#[2, 2, 2, 2, 3, 4, 4, 4, 5, 9, 43, 78]
a = {4:1,\
     5:2,\
     3:3,\
     2:6,\
     1:8}
print(sorted(a.items()))
#[(1, 8), (2, 6), (3, 3), (4, 1), (5, 2)]
@key值的运用
var = [[1,2],[2,3],[1,5],[2,2]]
var.sort(key=lambda x:list(x)[1])	#意思就是第二个
print(var)
#[[1, 2], [2, 2], [2, 3], [1, 5]]

sort与sorted的区别

相同点

• 参数都一样
• 功能一样

不同点

• 适用范围不同，sort只能用于列表，而sorted能作用于字符串等其他有序容器
• sort无返回值，改变源列表，sorted返回一个排序的列表

Python3 List copy()方法

描述

copy() 函数用于复制列表，类似于 **a[:]**。

语法

copy()方法语法：

list.copy()

参数

• 无。

返回值

返回复制后的新列表。

实例

var = [1,2,3,4,5,6,7,8,9,10]
res = var.copy()
res.remove(10)
print(res)
print(var)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]
#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#复制一份副本，副本和源文件不互相影响
@当然，例外还是来了
var = [1,2,3,[11,22,33]]
res = var.copy()
del res[3][2]
print(res)
print(var)
#[1, 2, 3, [11, 22]]
#[1, 2, 3, [11, 22]]
#在删除多维列表中的数据时会影响到源列表

内置函数

• max(list)：返回列表最大值
• min(list)：返回列表最小值
• list(sep:元组)：将元组转换为列表

浅拷贝于深拷贝

• 简单的拷贝就可以把列表复制一份
• 在拷贝一个多维列表时怎么办

浅拷贝

• 只能拷贝当前列表，不能拷贝多维列表

@多维列表的操作问题
var = [1,2,3,[11,22,33]]
res = var.copy()
del res[3][2]
print(res)
print(var)
#[1, 2, 3, [11, 22]]
#[1, 2, 3, [11, 22]]
#在删除多维列表中的数据时会影响到源列表
原因是什么？
var = [1,2,3,[11,22,33]]
res = var.copy()
del res[3][2]
print(res[2],id(res[2]))
print(var[2],id(var[2]))
#3 2007817218416
#3 2007817218416
#通过ID检测，发现列表中的多维列表是同一个元素
#也就是说他们所用的地址是相同的，这就不难解释为什么会出现这种情况了

深拷贝

• 就是不光拷贝当前列表，还拷贝了多为列表中的元素

import copy
var = [1,2,3,[11,22,33]]
new = copy.deepcopy(var)
del new[3][1]
print(var,id(var[3]))
print(new,id(new[3]))
#[1, 2, 3, [11, 22, 33]] 1879437923520
#[1, 2, 3, [11, 33]] 1879437922368
#这下就没问题了，使用拷贝的时候注意实际情况

列表推导式

实例-基本列表推导式

语法

变量 = [ 变量或变量的处理结果 for 变量 in 容器类型数据]

@求0-9平方和
#普通方法
var = []
for i in range(10):
    var.append(i**2)
print(var)
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#使用map和list完成
var = list(map(lambda x:x**2,range(10)))
print(var)
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#列表推导式
var = [i**2 for i in range(10)]
print(var)
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#和第一种是一样的，不要慌，多练一下就明白了
@'1234'->[2,4,6,8]
#列表推导式
var = '1234'
new = [int(i)*2 for i in var]
print(new)
#[2, 4, 6, 8]
#使用位运算
var = '1234'
new = [int(i) << 1 for i in var]	#<< 二进制左移一位
print(new)
#[2, 4, 6, 8]

实例-加判断

语法

变量 = [变量或变量的处理结果	for	i 	in	容器数据类型	田间表达式]

实例

@求0-9偶数
#常规方法
var = []
for i in range(10):
    if i % 2 == 0:
        var.append(i)
print(var)
#[0, 2, 4, 6, 8]
#列表推导式
var = [i for i in range(10) if i % 2 == 0]
print(var)
#[0, 2, 4, 6, 8]

多循环

@[1,2,3][3,1,4],两两组合，不能重复元素
#常规方法
var = []
for i in [1,2,3]:
    for j in [3,1,4]:
        if i != j:
            var.append((i,j))
print(var)
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
#推导式
var = [(x,y) for x in [1,2,3] for y in [3,1,4] if x!=y]
print(var)
#[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

嵌套

@3*4的矩阵，行列互转，并组合成列表
#普通方法
vat =[
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
]
new = []
for i in range(4):
    res = []	#每次循环重新定义列表，防止堆叠
    for var in vat:
        res.append(var[i])
    new.append(res)
print(new)
#[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
#列表推导式
vat =[
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
]
var = [[row[i] for row in vat] for i in range(4)]
print(var)
#[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

课外题

给定一个正整数,编写程序计算有多少对质数的和等于输入的这个正整数，并输出结果。输
入值小于1000。
如，输入为10,程序应该输出结果为2。(共 有两对质数的和为1日,分别为(5,5),(3,7))
# [2,3,5,7]
-输入描述:
输入包括一个整数n,(3 ≤n < 1000)
输出描述:10
输出对数:2

列表练习题

题目

字典键值转换

#{'user':'admin','age':20,'phone':15179646923}
列表['user=admin','age=20','phone=15179646923']
字符user=admin&age=20&phone=15179646923
要求：使用列表推导式完成
#普通方法
vdict ={'user':'admin','age':20,'phone':15179646923}
var = []
for i in vdict:
    var.append(i+'='+str(vdict[i]))
var = '&'.join(var)
print(var)
#user=admin&age=20&phone=15179646923
#推导式
var = [i + '=' + str(vdict[i]) for i in vdict]
var = '&'.join(var)
print(var)
#user=admin&age=20&phone=15179646923

列表字符转小写

#['AAAAAA','bbBb','CCCcc']==>['aaaaa','bbbbb','ccccc']
要求：列表推导式完成
#普通方法
vlist = ['AAAAAA','bbBb','CCCcc']
var = str(vlist).lower()
print(var)
#['aaaaaa', 'bbbb', 'ccccc']
#列表推导式
vlist = ['AAAAAA','bbBb','CCCcc']
var = [i.lower() for i in vlist]
print(var)
#['aaaaaa', 'bbbb', 'ccccc']

奇数与偶数

x = 0~5的偶数，y = 0~5的奇数，x,y组成元组，放到列表中
要求：[(0, 1), (0, 3), (0, 5), (2, 1), (2, 3), (2, 5), (4, 1), (4, 3), (4, 5)]
#普通方法
vlist = []
for x in range(6):
    for y in range(6):
        if x % 2 == 0 and y % 2 == 1:
            vlist.append((x,y))
print(vlist)
#[[0, 1], [0, 3], [0, 5], [2, 1], [2, 3], [2, 5], [4, 1], [4, 3], [4, 5]]
#推导式
var = [[x,y]for x in range(6)for y in range(6) if x % 2 == 0 and y % 2 == 1]
print(var)
#[[0, 1], [0, 3], [0, 5], [2, 1], [2, 3], [2, 5], [4, 1], [4, 3], [4, 5]]

使用推导式完成99乘法表

普通99乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(f'{j}*{i}={i*j}',end=' ')
    print()
#推导式
vlist = [f'{j}*{i}={i*j}' for i in range(1,10) for j in range(1,i+1)]
print(vlist)
['1*1=1', '1*2=2', '2*2=4', '1*3=3', '2*3=6', '3*3=9', '1*4=4', '2*4=8', '3*4=12', '4*4=16', '1*5=5', '2*5=10', '3*5=15', '4*5=20', '5*5=25', '1*6=6', '2*6=12', '3*6=18', '4*6=24', '5*6=30', '6*6=36', '1*7=7', '2*7=14', '3*7=21', '4*7=28', '5*7=35', '6*7=42', '7*7=49', '1*8=8', '2*8=16', '3*8=24', '4*8=32', '5*8=40', '6*8=48', '7*8=56', '8*8=64', '1*9=9', '2*9=18', '3*9=27', '4*9=36', '5*9=45', '6*9=54', '7*9=63', '8*9=72', '9*9=81']

M,N的乘积

M = [
[1,2,3],
[4,5,6],
[7,8,9]
]
N = [
[2,2,2],
[3,3,3],
[4,4,4]
]
要求：
(1)-->[2,4,6,8,12,15,18,28,32,36]
(2)-->[[2,4,6],[12,15,18],[28,32,36]]
(1)
普通方法
for i in range(3):
    for j in range(3):
        vlist.append(M[i][j]*N[i][j])
print(vlist)
#[2, 4, 6, 12, 15, 18, 28, 32, 36]
推导式
var = [M[i][j]*N[i][j] for i in range(3) for j in range(3)]
print(var)
#[2, 4, 6, 12, 15, 18, 28, 32, 36]
(2)
普通方法
vlist = []
for i in range(3):
    res = []
    for j in range(3):
        res.append((M[i][j]*N[i][j]))
    vlist.append((res))
print(vlist)
#[[2, 4, 6], [12, 15, 18], [28, 32, 36]]
vlist =  [[M[j][i]*N[j][i] for i in range(3)] for j in range(3)]
print(vlist)
#[[2, 4, 6], [12, 15, 18], [28, 32, 36]]

详解元组

• 原组和列表一样都是一组有序的数据的组合
• 元组的元素定义后不可修改，所以叫不可变数据类型

元组定义

• 定义元组 变量 = ()或者变量 =tuple()
• 还可以使用 变量 = (1,2,3)定义有数据的元组
• 注意：如果元组中只有一个元素时，必须加逗号 变量 = (1,)
• 特例：变量 = 1,2,3这种方式也可以定义为一个元组

宇宙的相关操作

• 因为元组不可更改，所以只能用索引访问，不能进行其他操作
• 元组也是可以使用切片方式获取元素的

元组的切片操作

实例

var = (1,2,3,4,5)
res = var[:]    #获取全部
res = var[::]   #获取全部
res = var[1:]   #从索引1开始
res = var[1:3]  #从1开始到2结束
res = var[1:5:2]#从1开始到4结束
res = var[:3]   #到3结束
res = var[::2]  #间隔为2
res = var[5:1:-1]#逆序，从5到3
print(res)
@index索引
var = ('张学友','吴孟达','柳岩','吴恩达')
res = var.index('吴孟达',1,3)
print(res)
#1
@元组加、乘法运算
var = (1,2,3)+('a','b')
res = (1,2,3)*3
print(var)
print(res)
#(1, 2, 3, 'a', 'b')
#(1, 2, 3, 1, 2, 3, 1, 2, 3)
@in 与 not in
var = (1,2,3)+('a','b')
res = (1,2,3)*3
var = 2 in var
res = 4 in res
print(var,res)
#True False

元组推导式

定义

• 又叫生成器

• 列表推导式返回列表，元组推导式返回生成器

推导式

语法

元组推导式 ==> (变量运算 for i in 容器) ==> 结果 是一个 生成器

生成器

生成器是一个特殊的迭代器，生成器可以自定义，也可以使用元组推导式去定义

生成器时按照某种算法去推算下一个数据或结果，只需要往内存中存储一个生成器，节约内存，提升性能

总结

1. 里面是推导式，外面是一个()的结果就是一个生成器

2. 自定义生成器。含有yield关键字的函数就是生成器

   含有yield关键字的函数，返回的是一个迭代器，换句话说，生成器函数就是一个返回迭代器的函数

实例

var = [1,2,3,4,5,6,7,8,9]
new = (i**2 for i in var)
print(new)
#<generator object <genexpr> at 0x000002929F5AFB30>
#<生成器对象在0x000002929F5AFB30>
如何使用操作生成器？
	生成时迭代器的一种，所以可以使用迭代器的操作方法操作生成器
使用@next()
var = [1,2,3,4,5,6,7,8,9]
new = (i**2 for i in var)
print(next(new))
#1
@使用list(),tuple()
var = [1,2,3,4,5,6,7,8,9]
new = (i**2 for i in var)
print(list(new))
#[1, 4, 9, 16, 25, 36, 49, 64, 81]
@使用for循环
var = [1,2,3,4,5,6,7,8,9]
new = (i**2 for i in var)
for i in new:
    print(i,end=' ')
#1 4 9 16 25 36 49 64 81 

生成器与yield关键字

• yield与return类似
• 共同点：执行到这个关键字后会把结果返回
• 不同点：
  • rerun 会把结果返回，并结束当前函数的使用
  • yield 会把结果返回，并记住当前代码执行的位置，下一次执行会变更为下一个结果

实例

@return
def hello():
    print('hello 1')
    return 1
    print('hello 2')
    return 2
res =hello()
print(res)
#hello 1	#return怎么调用也只会返回一次，因为它一幅画就结束函数了
#1
@yield
def hello():
    print('hello 1')
    yield 1
    print('hello 2')
    yield 2
res = hello()
next(res)	#yield调用一次返回一次结果，前提是不超出范围
next(res)	#用next是因为迭代器不能用print只能用next（实际不止）
#hello 1
#hello 2
@使用生成器返回迭代器
print(list(res))
#hello 1
#hello 2
#[1, 2]
for i in res:	#res在这里是生成器，因为引用了yield关键字
    print(i)
#hello 1
#1
#hello 2
#2

生成器与迭代器的区别

1. 迭代器由iter()方法转换可迭代对象完成
2. 生成器由yield关键字返回形成，也可以由元组推导式返回形成
3. next()调用迭代器返回的是迭代器中的元素（还需要print打印出来），next()调用yield关键字直接返回结果
4. yield关键字是记住上一次返回的对象，并且记录上下文，而迭代器只管返回，两个在栈溢出后都会报错，并无太大区别。

练习题

斐波那契

def feibo(num):
    a,b,i = 0,1,0
    while i < num:
        yield b
        a,b = b,a+b
        i += 1
num = int(input())
res = feibo(num)
print(list(res))
#[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
#元组推导式
from math import sqrt
a,b =   (1 + sqrt(5)) / 2,(1 - sqrt(5)) / 2
var = (int((a**i-b**i)/sqrt(5)) for  i in range(1,10))
for i in range(9):
    print(next(var),end=' ')
#1 1 2 3 5 8 13 21 34
#抄的，看不懂

详解字典

字典也是一种数据的集合，由键值对组成，不能重复

键由字符串或整型组成

定义

1. 使用{}定义

   vdict = {'a':1,'b':2}

2. 使用dict函数定义

   vdict = dict(name = 'zhangsan',sex = '男')

3. 数据类型转换

   vdict = dict(['a',1],['b',1],['c':1])

4. zip函数压缩

   var1 = [1,2,3,4]
   var2 = ['a','b','c','d']
   vdict = dict(zip(var1,var2))
   print(vdict)

字典的操作

拼接+重复

字典不能进行该操作，防止覆盖

获取

变量 = vdict[key]

修改

vdict[key] = 变量

删除

del vdict[key] 或 del vdict

添加

vdict[key] = 变量，重复覆盖

检测

res = ‘a’ in vdict,只能检测key,not in

遍历

vdict = {'a':1,'b':2,'c':3}
for i,j in vdict.items():
    print(i,j)

字典相关函数

长度

res = len(vdict),只检测key值

键

res = vdict.keys()

值

res = vdict.values()

键值对

res = vdict.items()

迭代器(iter())

vdict = {'a':1,'b':2}
res  = iter(vdict)
print(next(res))

移除pop()

res = vdict.pop('a')
print(vdict)

移除popitem()

res = vdict.popitem()#返回元组，因为不能改变
print(vdict)#后进先出
#popitem()无参

获取不存在get()

res = vdict.get('aa',False)#不存在默认返回None，可以指定
print(res)#
print(vdict)

更新update()

res = vdict.update({'b':6,'c':3,'d':4,'e':5})
print(res)	#存在则更新，不存在添加
print(vdict)
#None
#{'a': 1, 'b': 6, 'c': 3, 'd': 4, 'e': 5}

默认setdefault()

res = vdict.setdefault('c',3)#没有key则添加一个默认的key，可指定
print(res)
print(vdict)
#3
#{'a': 1, 'b': 2, 'c': 3}

字典推导式

键值交换

把字典中的键值位置进行交换
vdict = {'a':1,'b':2,'c':3}
var = {}
for k,v in vdict.items():
    var[v] = k
print(var)
推导式
newdict = {v:k for k,v in vdict.items()}
print(newdict)
注意：
newdict = {v for k,v in vdict.items()}
print(type(newdict))
#<class 'set'>#集合和字典很像，注意分辨

判断偶数，并交换键值

vdict = {'a':1,'b':2,'c':3,'d':4}
var ={v:k for k,v in vdict.items() if v % 2 == 0}
print(var)
#{2: 'b', 4: 'd'}

详解集合

确定的一组无序的数据的组合

• 确定的？集合中元素不重复

• 有多个数据组合的复合型数据(容器数据类型)

• 集合中的数据没有顺序

• 功能：成员检测、去重；交、并、差和对称差集

集合的定义

• 可以直接使用{}来定义（没有键值就是集合）
• 使用set()进行定义和转换
• 可以使用集合推导式进行定义

注意：集合中的元素不会重复，集合中存放的数据：Number，Strings，Tupl，冰冻集合

集合的基本操作和常规函数

定义

vague = {112,0,False,True,(1,2,3)}
print(vague)

检测

vague = {112,0,False,True,(1,2,3)}
res = 112 in vague
print(res)
#True

长度len()

vague = {112,0,False,True,(1,2,3)}
res = len(vague)
print(res)
#4	#集合中0 = false

遍历

vague = {112,0,False,True,(1,2,3)}
for i in vague:
    print(i,type(i))
#    112 <class 'int'>
#0 <class 'int'>
#(1, 2, 3) <class 'tuple'>
#True <class 'bool'>

追加add()

vague = {112,0,False,True,(1,2,3)}
for i in range(3,6):
    vague.add(i)
print(vague)
#{0, True, 3, 4, 5, (1, 2, 3), 112}

移除pop

vague = {112,0,False,True,(1,2,3)}
for i in range(3,6):	#集合不能用def 删除
    vague.add(i)
vague.pop()
print(vague)
#{True, 3, 4, 5, (1, 2, 3), 112}#随机删除集合（特性）一个元素

删除remove()

vague = {112,0,False,True,(1,2,3)}
for i in range(3,6):
    vague.add(i)
vague.remove((1,2,3))#指定删除元素
print(vague)
#{0, True, 3, 4, 5, 112}

删除discard()

删除不报错（上面的方法删除时为空会报错）

冰冻集合

集合的推导式

集合的运算