python2 四五章

目录

函数

语法

注意事项

None类型

在if判断上：

定义变量上：

函数如何返回None

函数的嵌套调用

局部变量

全局变量

global关键字

数据容器

list列表

列表的下标索引

列表的方法

特点

列表的遍历

元组

元组的方法

元组的特点

字符串

字符串的常用操作

字符串特点

序列

序列的常用操作--切片

集合

基本语法

集合的常用操作

集合的特点

字典

字典的定义

字典的嵌套

字典的常用操作

字典的特点

容器特点对比

数据容器的通用操作

len(容器)

max(容器)

min(容器)

转换功能

---

函数

定义：函数是组织好的，可重复使用的，用来实现特定功能的代码段

语法

def 函数名 (传入参数):

        函数体

        return 返回值

注意事项

①参数如果不需要可以省略

②返回值若不需要，可以省略

③函数必须先定义后使用

None类型

无返回值的函数，实际上就是返回了：None这个字面量

None表示：空的，无实际意义的意思

在if判断上：

None等同于False

一般用于在函数中返回None，配合if判断做相关处理

定义变量上：

定义变得，但暂时不需要变量有具体值，可以用None来代替

函数如何返回None

不使用return语句即返回None

主动return None

函数的嵌套调用

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次函数A执行的位置。

局部变量

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）

主要分为两类：局部变量和全局变量

局部变量：定义在函数体内部的变量，即只在函数体内生效

局部变量的作用域：在函数体内部，临时保存数据，即当函数调用完成之后，则销毁局部变量。

全局变量

全局变量：在函数体内、体外都能生效的变量

global关键字

使用global关键字可以在函数内部声明变量为全局变量。

数据容器

list列表

字面量：[元素1， 元素2，元素3.....]

定义变量：

变量名称 = [元素1，元素2，..... ]

定义空列表：

变量名称 = [ ]

变量名称 = list()

列表内的每一个数据，称之为元素

①以 [ ] 作为标识，

②列表内每一个元素之间，用逗号隔开

列表的下标索引

可以是正向也可以是反向

正向：从前向后的方向，编号从0开始递增

反向：从后向前的方向，编号从-1开始递减

方法：在python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法。

列表的方法

① 查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index(元素)

index就是列表对象（变量）内置的方法（函数）

mylist = ['itheima', 'itcast', 'python']
index = mylist.index('itheima')
print(index)  #0

② 修改特定位置（索引）的元素值

语法：列表[下标] = 值

mylist = ['itcast', 'itheima', 'python']
mylist[0] = '传智教育'
print(mylist)  #['传智教育', 'itheima', 'python']

③ 插入元素

语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素

mylist = ['itcast', 'itheima', 'python']
mylist.insert(1,'best')
print(mylist) #['itcast', 'best', 'itheima', 'python']

④ 追加元素

语法：列表.append(元素)，将指定元素，追加到列表的尾部

mylist = ['itcast', 'itheima', 'python']
mylist.append('jingjing')
print(mylist)   #['itcast', 'itheima', 'python', 'jingjing']

⑤ 追加元素方式二

语法：列表.extend(其它数据容器)，将其他数据容器的内容取出，依次追加到列表尾部

mylist = ['itcast', 'itheima', 'python']
list2 =[ '1', '2', '3']
mylist.extend(list2)
print(mylist)   #['itcast', 'itheima', 'python', '1', '2', '3']

⑥ 删除元素

语法1：del 列表[ 下标 ]

mylist = ['itcast', 'itheima', 'python']
del mylist[2]
print(mylist)   #['itcast', 'itheima']

语法2：列表.pop( 下标 )

mylist = ['itcast', 'itheima', 'python']
element = mylist.pop(2)
print(mylist)   #['itcast', 'itheima']
print(element)  #python

⑦ 删除某个元素在列表中的第一个匹配项

语法：列表.remove( 元素 )

mylist = ['itcast', 'itheima', 'itcats', 'itheima', 'python']
mylist.remove('itheima')
print(mylist)   #['itcast', 'itcats', 'itheima', 'python']

⑧ 清空列表

语法：列表.clear( )

⑨ 统计某个元素在列表内的数量

语法：列表.count( 元素 )

mylist = ['itcast', 'itheima', 'itcats', 'itheima', 'python']
count = mylist.count('itheima')
print(count)    #2

使用方式	作用
列表.append(元素)	向列表中追加一个元素
列表.extend(容器)	将数据容器的内容依次取出，追加到列表的尾部
列表.insert( 下标，元素)	在指定下标处，插入指定的元素
del 列表[ 下标 ]	删除列表指定下标元素
列表.pop(下标)	山粗列表指定下标元素
列表.remove(元素)	从前向后，删除此元素第一个匹配项
列表.clear()	清空列表
列表.count(元素)	统计此元素在列表中出现的次数
列表.index(元素)	查找指定元素在列表的下标，找不到报错ValueEeeor
len(列表)	统计容器内有多少元素

特点

1. 可以容纳不同类型的元素
2. 数据是有序存储的
3. 允许数据重复存在
4. 可以修改

列表的遍历

①while循环

def list_while_func():
    mylist = ['传智教育', '黑马程序员', 'python']
    index = 0
    while index < len(mylist):
        print(mylist[index])
        index += 1

list_while_func()
# 传智教育
# 黑马程序员
# python

②for循环

def list_for_func():
    mylist = ['传智教育', '黑马程序员', 'python']
    for i in mylist:
        print(i)
list_for_func()
# 传智教育
# 黑马程序员
# python

元组

定义：元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

定义元组字面量：（元素1，元素2，.......）

定义元组变量：变量名称 = （元素1，元素2.......）

定义空元组：

方式1：变量名称 = （）

方式2：变量名称 = tuple（）

注：定义单个元素的元组，元素后面必须写上逗号，不然系统识别为字符串类型

t1 = ('hello')
print(type(t1)) #<class 'str'>
t2 = ('hello', )
print(type(t2)) #<class 'tuple'>

元组的方法

方法	作用
index()	查找某个数据，如果数据存在返回对应的下标，否则报错
count()	统计某个数据在当前元组中出现的次数
len(元组)	统计元组内的元素个数

元组的特点

1. 可以容纳不同类型的数据
2. 数据是有序存储的
3. 允许重复数据存在
4. 不可以修改元组的内容（但是可以修改内部list的内部元素）
5. 支持for循环

注：

t = (1, 2, ['itheima', 'itcast'])
t[2][0] = '黑马程序员'
t[2][1] = '传智教育'
print(t)    #(1, 2, ['黑马程序员', '传智教育'])

字符串

字符串可以通过下标进行访问：正向和反向

字符串是一个无法修改的数据容器

字符串的常用操作

① 查找特定字符串的下标索引值

语法：字符串.index( 字符串 )

② 字符串的替换

语法：字符串.replace( 字符串1， 字符串2)

功能：将字符串内的全部：字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到一个新的字符串

③ 字符串的分割

语法：字符串.split( 分隔符字符串 )

功能：按照指定的分隔符字符串将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

my_str = 'hello python itheima itcast'
list = my_str.split(' ')
print(list) #['hello', 'python', 'itheima', 'itcast']

④ 字符串的规整操作（去前后空格）

语法：字符串.strip( )

⑤ 字符串的规整操作（去前后指定字符串）

语法：字符串.strip( 字符串 ）

注意：传入的需要删除的字符串，是将其分割为多个集合，原字符串中满足其一就会被删除掉

my_str = '    itheima and itcast     '
new_my_str = my_str.strip()
print(new_my_str)   #itheima and itcast
my_str = '21itheima and itcast12'
new_my_str = my_str.strip('123')
print(new_my_str)   #itheima and itcast

⑥ 统计字符串在某字符串的出现的次数

语法：字符串.count( 字符串 )

⑦ 统计字符串的长度

语法：len( 字符串 )

操作	说明
字符串[ 下标 ]	根据下标索引取出特定位置字符
字符串.index(字符串)	查找给定字符的第一个匹配项的下标
字符串.replace(字符串1，字符串2)	将字符串内的全部字符串1，替换为字符串2，不会修改原字符串，而是得到一个新的字符串
字符串.split(字符串)	按照给定字符串，对字符串进行分割，不修改原字符串，而是得到一个新的列表
字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
字符串.count( )	统计字符串内某字符串的出现次数
len(字符串)	统计字符串的字符个数

字符串特点

1. 只可以存储字符串
2. 长度任意（取决于内存大小）
3. 支持下标索引
4. 允许重复字符串存在
5. 不可以修改（和元组一样）
6. 支持for循环

序列

序列是指：内容连续、有序，可以使用下标索引的一类数据容器

列表、元组、字符串均可以视为序列

序列的常用操作--切片

切片：从一个序列中，取出一个子序列

语法：序列[ 起始下标：结束下标：步长 ]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新的序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔

        步长1表示，挨个取元素

        步长2表示，每次跳过1个元素取

        步长N表示，每次跳过N-1个元素取

        步长为负数，反向取（注意，起始下标和结束下标也要反向标记）

集合

基本语法

定义集合字面量:

{元素1，元素2，........}

定义集合变量:

变量名称 = {元素1，元素2，......}

定义空集合：

变量名称 = set( )

集合的常用操作

集合是无序的，集合不支持下标索引访问

集合和列表一样，是允许修改的

① 添加新元素

语法：集合.add( 元素 )

将指定元素，添加到集合内，集合本身会被修改

② 移除元素

语法：集合.remove( 元素 )，将指定元素，从集合内移除

③ 从集合中随机取出元素

语法：集合.pop()，从集合中随机取出一个元素

④ 清空集合

语法：集合.clear()

⑤ 取两个集合的差集

语法：集合1.difference( 集合2 )，功能：取出集合1和集合2的差集（集合1有而集合2没有的）

结果：得到一个新集合，集合1和集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 =set1.difference(set2)
print(set3) #{2, 3}

⑥ 消除2个集合的差集

语法：集合1.difference_update(集合2)

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素，所以集合1的内容会发生改变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1) #{2, 3}
print(set2)#1, 5, 6}

⑦ 两个集合的合并

语法：集合1.union(集合2)

功能：将集合1和集合2组成新集合，集合1和集合2的内容不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3) #{1, 2, 3, 5, 6}

⑧ 统计集合的元素数量

语法：len( 集合 )

⑨ 集合的遍历：只能使用for循环，因为无序，所以不能使用while

操作	说明
集合.add( 元素 )	集合内添加一个元素
集合.remove(元素)	移除集合内指定的元素
集合.pop()	从集合中随机取出一个元素
集合.clear()	清空集合
集合1.difference(集合2)	得到一个新集合，内含2个集合的差集原有的俩个经济和内容不变
集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素，集合1被修改，集合2不变
集合1.union(集合2）	得到一个新集合，内涵两个集合的全部元素，原有的两个集合内容不变
len(集合)	统计集合的元素数量

集合的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 数据是无序存储的
• 不允许数据重复存在
• 可以修改
• 支持for循环

字典

字典的定义

定义字典字面量

{key: value, key: value,......}

定义字典变量

my_dict = {key: value, key: value,......}

定义空字典

my_dict = { }

my_dict = dict()

注意：字典同集合一样，不可以使用下标索引，但是字典可以通过key值来取得对应的Value

字典的嵌套

• 字典的key和value可以是任意数据类型（key不可为字典），所以字典是可以嵌套的
• 字典内的key不允许重复，重复添加等同于覆盖原有数据
• 字典不可以使用下标索引，而是通过key检索value

字典的常用操作

① 新增元素

语法：字典[ key ] = value，结果：字典被修改，新增了元素

my_dict1 = {
    '王力宏': {'语文': 77, '数学': 88, '英语': 78},
    '周杰伦': {'语文': 87, '数学': 80, '英语': 72},
    '林俊杰': {'语文': 37, '数学': 84, '英语': 70},
}
my_dict1['静静'] = {'语文': 97, '数学': 99, '英语': 98}
print(my_dict1)
#{'王力宏': {'语文': 77, '数学': 88, '英语': 78}, 
# '周杰伦': {'语文': 87, '数学': 80, '英语': 72}, '
# 林俊杰': {'语文': 37, '数学': 84, '英语': 70},
# '静静': {'语文': 97, '数学': 99, '英语': 98}}

② 更新元素

语法：字典[ key ] = value，结果：字典被修改，元素被更新

注意：字典的可以不可以重复，所以对于已存在的key执行上述操作，就是更新value值

my_dict1 = {
    '王力宏': {'语文': 77, '数学': 88, '英语': 78},
    '周杰伦': {'语文': 87, '数学': 80, '英语': 72},
    '林俊杰': {'语文': 37, '数学': 84, '英语': 70},
}
my_dict1['周杰伦'] = {'语文': 97, '数学': 99, '英语': 98}
print(my_dict1)
#{'王力宏': {'语文': 77, '数学': 88, '英语': 78},
# '周杰伦': {'语文': 97, '数学': 99, '英语': 98},
# 林俊杰': {'语文': 37, '数学': 84, '英语': 70}}
my_dict1['周杰伦']['数学'] = 40
print(my_dict1)
#{'王力宏': {'语文': 77, '数学': 88, '英语': 78}, 
# '周杰伦': {'语文': 97, '数学': 40, '英语': 98}, '
# 林俊杰': {'语文': 37, '数学': 84, '英语': 70}}

③ 删除元素

语法：字典.pop(key)，结果：获得指定key的value，同时字典被修改，指定key的数据被删除

my_dict1 = {
    '王力宏': {'语文': 77, '数学': 88, '英语': 78},
    '周杰伦': {'语文': 87, '数学': 80, '英语': 72},
    '林俊杰': {'语文': 37, '数学': 84, '英语': 70},
}
score = my_dict1.pop('周杰伦')
print(score)    #{'语文': 87, '数学': 80, '英语': 72}
print(my_dict1)#{'王力宏': {'语文': 77, '数学': 88, '英语': 78}, '林俊杰': {'语文': 37, '数学': 84, '英语': 70}}

④ 清空字典

语法：字典.clear()

⑤ 获取字典中全部的key

语法：字典.keys()

my_dict1 = {
    '王力宏': {'语文': 77, '数学': 88, '英语': 78},
    '周杰伦': {'语文': 87, '数学': 80, '英语': 72},
    '林俊杰': {'语文': 37, '数学': 84, '英语': 70},
}
keys = my_dict1.keys()
print(keys) #dict_keys(['王力宏', '周杰伦', '林俊杰'])

⑥ 遍历字典

方式1：

my_dict1 = {
    '王力宏': {'语文': 77, '数学': 88, '英语': 78},
    '周杰伦': {'语文': 87, '数学': 80, '英语': 72},
    '林俊杰': {'语文': 37, '数学': 84, '英语': 70},
}
for key in my_dict1.keys():
    print(f'{key}:{my_dict1[key]}')
 #王力宏:{'语文': 77, '数学': 88, '英语': 78}
# 周杰伦:{'语文': 87, '数学': 80, '英语': 72}
# 林俊杰:{'语文': 37, '数学': 84, '英语': 70}

方式2：

my_dict1 = {
    '王力宏': {'语文': 77, '数学': 88, '英语': 78},
    '周杰伦': {'语文': 87, '数学': 80, '英语': 72},
    '林俊杰': {'语文': 37, '数学': 84, '英语': 70},
}
for key in my_dict1:
    print(f'{key}:{my_dict1[key]}')
#王力宏:{'语文': 77, '数学': 88, '英语': 78}
# 周杰伦:{'语文': 87, '数学': 80, '英语': 72}
# 林俊杰:{'语文': 37, '数学': 84, '英语': 70}

⑦ 统计字典的元素数量

语法：len(字典)

操作	说明
字典[ key ]	获取指定key对应的value值
字典[ key ] = value	添加或更新键值对
字典.pop(key)	取出key对应的value并在字典内删除此key的键值对
字典.clear()	清空字典
字典.keys()	获取字典的全部key，可用于for循环遍历字典
len(字典)	计算字典内的元素数量

字典的特点

• 可以容纳多个数据
• 可以容纳多个不同数据类型的数据
• 每一份数据都是key-value键值对
• 可以通过key获取到value，key不可以重复
• 不支持下标索引
• 可以修改
• 支持for循环，不支持while循环

容器特点对比

	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	key: value key:除字典外任意类型 value:任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	有序	有序	有序	无序	无序

数据容器的通用操作

len(容器)

统计容器的元素个数

max(容器)

统计容器的最大元素

min(容器)

统计容器的最小元素

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = 'abcdefg'
my_set = {1, 2, 3, 4, 5}
my_dict = {'key1': 1, 'key2': 2,'key3': 3, 'key4': 4,'key5': 5}
print(max(my_list)) #5
print(max(my_tuple))    #5
print(max(my_str))  #g
print(max(my_set))  #5
print(max(my_dict)) #key5

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = 'abcdefg'
my_set = {1, 2, 3, 4, 5}
my_dict = {'key1': 1, 'key2': 2,'key3': 3, 'key4': 4,'key5': 5}
print(min(my_list)) #1
print(min(my_tuple))    #1
print(min(my_str))  #a
print(min(my_set))  #1
print(min(my_dict)) #key1

转换功能

① list(容器)：给定容器转换为列表

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = 'abcdefg'
my_set = {1, 2, 3, 4, 5}
my_dict = {'key1': 1, 'key2': 2,'key3': 3, 'key4': 4,'key5': 5}
print(list(my_tuple))   #[1, 2, 3, 4, 5]
print(list(my_str))     #['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list(my_set)) #[1, 2, 3, 4, 5]
print(list(my_dict))    #['key1', 'key2', 'key3', 'key4', 'key5']

② str(容器)：给定容器转换为字符串

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = 'abcdefg'
my_set = {1, 2, 3, 4, 5}
my_dict = {'key1': 1, 'key2': 2,'key3': 3, 'key4': 4,'key5': 5}
print(str(my_list))   #([1, 2, 3, 4, 5]
print(str(my_tuple))     #(1, 2, 3, 4, 5)
print(str(my_set)) #{1, 2, 3, 4, 5}
print(str(my_dict))    #{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

③ tuple(容器)：给定容器转换为元组

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = 'abcdefg'
my_set = {1, 2, 3, 4, 5}
my_dict = {'key1': 1, 'key2': 2,'key3': 3, 'key4': 4,'key5': 5}
print(tuple(my_list))   #(1, 2, 3, 4, 5)
print(tuple(my_str))     #('a', 'b', 'c', 'd', 'e', 'f', 'g')
print(tuple(my_set)) #(1, 2, 3, 4, 5)
print(tuple(my_dict))    #('key1', 'key2', 'key3', 'key4', 'key5')

④ set(容器)：给定容器转换为集合

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = 'abcdefg'
my_set = {1, 2, 3, 4, 5}
my_dict = {'key1': 1, 'key2': 2,'key3': 3, 'key4': 4,'key5': 5}
print(set(my_list))   #{1, 2, 3, 4, 5}
print(set(my_tuple))     #{1, 2, 3, 4, 5}
print(set(my_str)) #{'d', 'a', 'b', 'f', 'e', 'c', 'g'}
print(set(my_dict))    #{'key4', 'key1', 'key5', 'key2', 'key3'}

⑤ sorted(序列，[reverse = True]):排序，reverse = True表示降序得到一个排好的列表

my_list = [3, 2, 1, 4, 5]
my_tuple = (3, 2, 1, 4, 5)
my_str = 'adbcefg'
my_set = {3, 2, 1, 4, 5}
my_dict = {'key3': 1, 'key2': 2,'key1': 3, 'key4': 4,'key5': 5}
print(sorted(my_list))   #{1, 2, 3, 4, 5}
print(sorted(my_tuple))     #[1, 2, 3, 4, 5]
print(sorted(my_str)) #['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(sorted(my_dict))    #['key1', 'key2', 'key3', 'key4', 'key5']