目录
知识点回顾
-
Python 中数据类型可以分为 数字型 和 非数字型
-
数字型
-
整型 (
int
) -
浮点型(
float
) -
布尔型(
bool
)-
真
True
非 0 数
—— 非零即真 -
假
False
0
-
-
复数型 (
complex
)-
主要用于科学计算,例如:平面场问题、波动问题、电感电容等问题
-
-
-
非数字型
-
字符串
-
列表
-
元组
-
字典
-
-
在
Python
中,所有 非数字型变量 都支持以下特点:-
都是一个 序列
sequence
,也可以理解为 容器 -
取值
[]
-
遍历
for in
-
计算长度、最大/最小值、比较、删除
-
链接
+
和 重复*
-
切片
-
01. 列表
1.1 列表的定义
-
List
(列表) 是Python
中使用 最频繁 的数据类型,在其他语言中通常叫做 数组 -
专门用于存储 一串 信息
-
列表用
[]
定义,数据 之间使用,
分隔 -
列表的 索引 从
0
开始-
索引 就是数据在 列表 中的位置编号,索引 又可以被称为 下标
-
注意:从列表中取值时,如果 超出索引范围,程序会报错
name_list = ["zhangsan", "lisi", "wangwu"]
name_zhang = "zhangsan"
name_lisi = "Lisi"
name_wangwu = "wangwu"
name_list = ["zhangsan", "LIsi", "wangwu"]
print(name_list[0])
print(name_list)
1.2 列表常用操作
-
在
ipython3
中定义一个 列表,例如:name_list = []
-
输入
name_list.
按下TAB
键,ipython
会提示 列表 能够使用的 方法 如下:
In [1]: name_list.
name_list.append name_list.count name_list.insert name_list.reverse
name_list.clear name_list.extend name_list.pop name_list.sort
name_list.copy name_list.index name_list.remove
序号 | 分类 | 关键字 / 函数 / 方法 | 说明 |
---|---|---|---|
1 | 增加 | 列表.insert(索引, 数据) | 在指定位置插入数据 |
del 关键字(科普)
-
使用
del
关键字(delete
) 同样可以删除列表中元素 -
del
关键字本质上是用来 将一个变量从内存中删除的 -
如果使用
del
关键字将变量从内存中删除,后续的代码就不能再使用这个变量了
del name_list[1]
在日常开发中,要从列表删除数据,建议 使用列表提供的方法
如果要取最后一个元素,除了计算索引位置外,还可以用-1 做索引,直
接获取最后一个元素:
>>> classmates[-1]
'Tracy'
以此类推,可以获取倒数第 2 个、倒数第 3 个:
>>> classmates[-2]
'Bob'
>>> classmates[-3]
'Michael'
关键字、函数和方法(科普)
-
关键字 是 Python 内置的、具有特殊意义的标识符
In [1]: import keyword
In [2]: print(keyword.kwlist)
In [3]: print(len(keyword.kwlist))
关键字后面不需要使用括号
-
函数 封装了独立功能,可以直接调用
函数名(参数)
函数需要死记硬背
-
方法 和函数类似,同样是封装了独立的功能
-
方法 需要通过 对象 来调用,表示针对这个 对象 要做的操作
对象.方法名(参数)
在变量后面输入
.
,然后选择针对这个变量要执行的操作,记忆起来比函数要简单很多
1.3 循环遍历
-
遍历 就是 从头到尾 依次 从 列表 中获取数据
-
在 循环体内部 针对 每一个元素,执行相同的操作
-
-
在
Python
中为了提高列表的遍历效率,专门提供的 迭代 iteration 遍历 -
使用
for
就能够实现迭代遍历
# for 循环内部使用的变量 in 列表
for name in name_list:
循环内部针对列表元素进行操作
print(name)
1.4 应用场景
-
尽管
Python
的 列表 中可以 存储不同类型的数据 -
但是在开发中,更多的应用场景是
-
列表 存储相同类型的数据
-
通过 迭代遍历,在循环体内部,针对列表中的每一项元素,执行相同的操作
-
name_list = ["zhangsan", "LIsi", "wangwu",12, 52]
name_list.insert(0,"helo")
for name in name_list:
print(name)
02. 元组
2.1 元组的定义
-
Tuple
(元组)与列表类似,不同之处在于元组的 元素不能修改-
元组 表示多个元素组成的序列
-
元组 在
Python
开发中,有特定的应用场景
-
-
用于存储 一串 信息,数据 之间使用
,
分隔 -
元组用
()
定义 -
元组的 索引 从
0
开始-
索引 就是数据在 元组 中的位置编号
-
info_tuple = ("zhangsan", 18, 1.75)
创建空元组
info_tuple = ()
元组中 只包含一个元素 时,需要 在元素后面添加逗号
info_tuple = (50, )
定义空元组和只有一个元素的元组。
Python 在显示只有 1 个元素的 tuple 时,也会加一个逗号,,以免你误解成数学计算意义上的括号。
另一种有序列表叫元组: tuple。 tuple 和 list 非常类似,但是 tuple 一旦
初始化就不能修改,比如同样是列出同学的名字:
>>> classmates = ('Michael', 'Bob', 'Tracy')
现在, classmates 这个 tuple 不能变了,它也没有 append(), insert()这样
的方法。其他获取元素的方法和 list 是一样的,你可以正常地使用
classmates[0], classmates[-1],但不能赋值成另外的元素。
不可变的 tuple 有什么意义?因为 tuple 不可变,所以代码更安全。如果可能,能用 tuple 代替 list 就尽量用 tuple。
最后来看一个“可变的”tuple:
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
这个 tuple 定义的时候有 3 个元素,分别是'a', 'b'和一个 list。不是说tuple 一旦定义后就不可变了吗?怎么后来又变了?
别急,我们先看看定义的时候 tuple 包含的 3 个元素:
表面上看, tuple 的元素确实变了,但其实变的不是 tuple 的元素,而是list 的元素。 tuple 一开始指向的 list 并没有改成别的 list,所以, tuple所谓的“不变”是说, tuple 的每个元素,指向永远不变。即指向'a',就不能改成指向'b',指向一个 list,就不能改成指向其他对象,但指向的这个 list 本身是可变的!理解了“指向不变”后,要创建一个内容也不变的 tuple 怎么做?那就必须保证 tuple 的每一个元素本身也不能变。
这个有点像c里面的int* const p = &a; 表示指针指向的地址不可变,但地址里存放什么东西可以变化。无组的每一个元素也像C里面的数组地址,在C里面int a[2]; a数据的地址也不能修改,为了释放内存,如果修改了就不能释放了。
list 和 tuple 是 Python 内置的有序集合,一个可变,一个不可变。
# list是一种有序的集合,可以随时添加和删除其中的元素。
classmates = ['Mich', 'Bob', 'Tra']
print(classmates)
print(len(classmates))
print(classmates[0], classmates[len(classmates)-1])
# 如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素
print(classmates[-1])
# list是一个可变的有序表,所以,可以往list中追加元素到末尾
classmates.append('Adam')
print(classmates)
# 也可以把元素插入到指定的位置,比如索引号为1的位置:
classmates.insert(2, 'Jack')
print(classmates)
# 要删除list末尾的元素,用pop()方法
classmates.pop()
print(classmates)
# 要删除指定位置的元素,用pop(i)方法,其中i是索引位置
classmates.pop(1)
print(classmates)
# 要把某个元素替换成别的元素,可以直接赋值给对应的索引位置
classmates[1] = 'Jue'
print(classmates)
# list里面的元素的数据类型也可以不同
L = ['Apple', 123, True]
print(L)
# list元素也可以是另一个list
s= ['python', 'java', ['asp', 'php'], 'scheme']
print(len(s))
s[1] = L
print(s)
'''
tuple
另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改
'''
classmates = ('Min', 'Bob', 'Ana')
print(classmates[1])
# tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来
t = (1, 2)
print(t)
t= ()
print(t)
t = (1)
print(t, type(t))
# 只有1个元素的tuple定义时必须加一个逗号,,来消除歧义
t = (1,)
print(t)
print(len(t), type(t))
# Python在显示只有1个元素的tuple时,也会加一个逗号,,以免你误解成数学计算意义上的括号。
L = [
['Apple', 'Google', 'Microsoft'],
['Java', 'Python', 'Ruby', 'PHP'],
['Adam', 'Bart', 'Lisa']
]
print(L[0][0])
print(L[1][1])
print(L[2][2])
2.2 元组常用操作
-
在
ipython3
中定义一个 元组,例如:info = ()
-
输入
info.
按下TAB
键,ipython
会提示 元组 能够使用的函数如下:
info.count info.index
有关 元组 的 常用操作 可以参照上图练习
2.3 循环遍历
-
取值 就是从 元组 中获取存储在指定位置的数据
-
遍历 就是 从头到尾 依次 从 元组 中获取数据
# for 循环内部使用的变量 in 元组
for item in info:
循环内部针对元组元素进行操作
print(item)
在
Python
中,可以使用for
循环遍历所有非数字型类型的变量:列表、元组、字典 以及 字符串提示:在实际开发中,除非 能够确认元组中的数据类型,否则针对元组的循环遍历需求并不是很多
2.4 应用场景
-
尽管可以使用
for in
遍历 元组 -
但是在开发中,更多的应用场景是:
-
函数的 参数 和 返回值,一个函数可以接收 任意多个参数,或者 一次返回多个数据
-
有关 函数的参数 和 返回值,在后续 函数高级 给大家介绍
-
-
格式字符串,格式化字符串后面的
()
本质上就是一个元组 -
让列表不可以被修改,以保护数据安全
-
-
info = ("zhangsan", 18)
print("%s 的年龄是 %d" % info)
元组和列表之间的转换,元组的元素不能修改,但可通过这样的转换后就可以修改了,之后再转换回去,别人就不能修改了。
-
使用
list
函数可以把元组转换成列表
list(元组)
-
使用
tuple
函数可以把列表转换成元组
tuple(列表)
03. 字典
3.1 字典的定义
-
dictionary
(字典) 是 除列表以外Python
之中 最灵活 的数据类型 -
字典同样可以用来 存储多个数据
-
通常用于存储 描述一个
物体
的相关信息
-
-
和列表的区别
-
列表 是 有序 的对象集合
-
字典 是 无序 的对象集合
-
-
字典用
{ }
定义 -
字典使用 键值对 存储数据,键值对之间使用
,
分隔-
键
key
是索引 -
值
value
是数据 -
键 和 值 之间使用
:
分隔 -
键必须是唯一的
-
值 可以取任何数据类型,但 键 只能使用 字符串、数字或 元组
-
xiaoming = {"name": "小明",
"age": 18,
"gender": True,
"height": 1.75}
3.2 字典常用操作
-
在
ipython3
中定义一个 字典,例如:xiaoming = {}
-
输入
xiaoming.
按下TAB
键,ipython
会提示 字典 能够使用的函数如下:
In [1]: xiaoming.
xiaoming.clear xiaoming.items xiaoming.setdefault
xiaoming.copy xiaoming.keys xiaoming.update
xiaoming.fromkeys xiaoming.pop xiaoming.values
xiaoming.get xiaoming.popitem
有关 字典 的 常用操作 可以参照上图练习
Unittest
'''
我们来编写一个Dict类,这个类的行为和dict一致,但是可以通过属性来访问,用起来就像下面这样:
'''
class Dict(dict):
"""docstring for Dict"""
def __init__(self, **kw):
super().__init__(**kw)
def __getattr__(self,key):
try:
return self[key]
except KeyError:
raise AttributeError(r"'Dict' object has no attribute '%s'" % key)
def __setattr__(self,key,value):
self[key]=value
d = Dict(a=1,b=2)
print(d['a'])
print(d.a)
# 为了编写单元测试,我们需要引入Python自带的unittest模块,编写mydict_test.py如下:
import unittest
class Test(unittest.TestCase):
def test_init(self):
d = Dict(a=1,b='test')
self.assertEqual(d.a,1)
self.assertEqual(d.b,'test')
self.assertTrue(isinstance(d,dict))
def test_key(self):
d = Dict()
d['key'] = 'value'
self.assertEqual(d.key,'value')
def test_attr(self):
d = Dict()
d.key = 'value'
self.assertTrue('key' in d)
self.assertEqual(d['key'],'value')
def test_keyerror(self):
d = Dict()
with self.assertRaises(KeyError):
value = d['empty']
def test_attrerror(self):
d = Dict()
with self.assertRaises(AttributeError):
value = d.empty
# 可以在单元测试中编写两个特殊的setUp()和tearDown()方法。
# 这两个方法会分别在每调用一个测试方法的前后分别被执行。
def setUp(self):
print('setUp...')
def tearDown(self):
print('tearDown...')
'''
编写单元测试时,我们需要编写一个测试类,从unittest.TestCase继承。
以test开头的方法就是测试方法,不以test开头的方法不被认为是测试方法,测试的时候不会被执行。
对每一类测试都需要编写一个test_xxx()方法。由于unittest.TestCase提供了很多内置的条件判断,我们只需要调用这些方法就可以断言输出是否是我们所期望的。最常用的断言就是assertEqual():
self.assertEqual(abs(-1), 1) # 断言函数返回的结果与1相等
另一种重要的断言就是期待抛出指定类型的Error,比如通过d['empty']访问不存在的key时,断言会抛出KeyError:
with self.assertRaises(KeyError):
value = d['empty']
而通过d.empty访问不存在的key时,我们期待抛出AttributeError:
with self.assertRaises(AttributeError):
value = d.empty
'''
unittest.main()
3.3 循环遍历
-
遍历 就是 依次 从 字典 中获取所有键值对
# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming:
print("%s: %s" % (k, xiaoming[k]))
提示:在实际开发中,由于字典中每一个键值对保存数据的类型是不同的,所以针对字典的循环遍历需求并不是很多
3.4 应用场景
-
尽管可以使用
for in
遍历 字典 -
但是在开发中,更多的应用场景是:
-
使用 多个键值对,存储 描述一个
物体
的相关信息 —— 描述更复杂的数据信息 -
将 多个字典 放在 一个列表 中,再进行遍历,在循环体内部针对每一个字典进行 相同的处理
-
card_list = [{"name": "张三",
"qq": "12345",
"phone": "110"},
{"name": "李四",
"qq": "54321",
"phone": "10086"}
]
请务必注意, dict 内部存放的顺序和 key 放入的顺序是没有关系的。
和 list 比较, dict 有以下几个特点:
1. 查找和插入的速度极快,不会随着 key 的增加而增加;
2. 需要占用大量的内存,内存浪费多。
而 list 相反:
1. 查找和插入的时间随着元素的增加而增加;
2. 占用空间小,浪费内存很少。
dict 可以用在需要高速查找的很多地方,在 Python 代码中几乎无处不在,
正确使用 dict 非常重要,需要牢记的第一条就是 dict 的 key 必须是不可
变对象。
这是因为 dict 根据 key 来计算 value 的存储位置,如果每次计算相同的
key 得出的结果不同,那 dict 内部就完全混乱了。这个通过 key 计算位
置的算法称为哈希算法(Hash)。
要保证 hash 的正确性,作为 key 的对象就不能变。在 Python 中,字符
串、整数等都是不可变的,因此,可以放心地作为 key。而 list 是可变
的,就不能作为 key:
set
set 和 dict 类似,也是一组 key 的集合,但不存储 value。由于 key 不能
重复,所以,在 set 中,没有重复的 key。
要创建一个 set,需要提供一个 list 作为输入集合:
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
注意,传入的参数[1, 2, 3]是一个 list,而显示的{1, 2, 3}只是告诉你
这个 set 内部有 1,2,3 这 3 个元素,显示的顺序也不表示 set 是有序的重复元素在 set 中自动被过滤:
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
通过 add(key)方法可以添加元素到 set 中,可以重复添加,但不会有效果:
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
set 可以看成数学意义上的无序和无重复元素的集合,因此,两个 set 可
以做数学意义上的交集、并集等操作:
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
set 和 dict 的唯一区别仅在于没有存储对应的 value,但是, set 的原理和
dict 一样,所以,同样不可以放入可变对象,因为无法判断两个可变对
象是否相等,也就无法保证 set 内部“不会有重复元素”。
'''
dict
Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。
'''
d = {'Min':95, 'Bob':75, 'Tra':85}
print(d, type(d))
print(d['Min'])
print(d)
# 如果key不存在,dict就会报错
# 要避免key不存在的错误,有两种办法,一是通过in判断key是否存在
print('tra' in d)
print('Tra' in d)
# 二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value
print(d.get('Tra'))
print(d.get('Tras'))
print(d.get('Tras', '没有该用户'))
# 要删除一个key,用pop(key)方法,对应的value也会从dict中删除
d.pop('Bob')
print(d)
'''
dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较,dict有以下几个特点:
1、查找和插入的速度极快,不会随着key的增加而增加;
2、需要占用大量的内存,内存浪费多。
而list相反:
1、查找和插入的时间随着元素的增加而增加;
2、占用空间小,浪费内存很少。
所以,dict是用空间来换取时间的一种方法。
'''
'''
dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。
要保证hash的正确性,作为key的对象就不能变。
在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key
'''
'''
set
set和dict类似,也是一组key的集合,但不存储value。
由于key不能重复,所以,在set中,没有重复的key。
'''
# 要创建一个set,需要提供一个list作为输入集合
s = set([1, 2, 3])
print(s)
print(type(s))
# 重复元素在set中自动被过滤
s = set([3, 23, 233, 12, 23, 3])
print(s)
# 通过add(key)方法可以添加元素到set中,可以重复添加,但不会有效果
s.add(4)
print(s)
s.add(4)
print(s)
# 通过remove(key)方法可以删除元素
s.remove(3)
print(s)
# set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作
s1 = set([1,2,3])
s2 = set([2,3,4])
print(s1 & s2)
print(s1 | s2)
04. 字符串
4.1 字符串的定义
-
字符串 就是 一串字符,是编程语言中表示文本的数据类型
-
在 Python 中可以使用 一对双引号
"
或者 一对单引号'
定义一个字符串-
虽然可以使用
\"
或者\'
做字符串的转义,但是在实际开发中:-
如果字符串内部需要使用
"
,可以使用'
定义字符串 -
如果字符串内部需要使用
'
,可以使用"
定义字符串
-
-
-
可以使用 索引 获取一个字符串中 指定位置的字符,索引计数从 0 开始
-
也可以使用
for
循环遍历 字符串中每一个字符
大多数编程语言都是用
"
来定义字符串
string = "Hello Python"
for c in string:
print(c)
4.2 字符串的常用操作
-
在
ipython3
中定义一个 字符串,例如:hello_str = ""
-
输入
hello_str.
按下TAB
键,ipython
会提示 字符串 能够使用的 方法 如下:
In [1]: hello_str. hello_str.capitalize hello_str.isidentifier hello_str.rindex hello_str.casefold hello_str.islower hello_str.rjust hello_str.center hello_str.isnumeric hello_str.rpartition hello_str.count hello_str.isprintable hello_str.rsplit hello_str.encode hello_str.isspace hello_str.rstrip hello_str.endswith hello_str.istitle hello_str.split hello_str.expandtabs hello_str.isupper hello_str.splitlines hello_str.find hello_str.join hello_str.startswith hello_str.format hello_str.ljust hello_str.strip hello_str.format_map hello_str.lower hello_str.swapcase hello_str.index hello_str.lstrip hello_str.title hello_str.isalnum hello_str.maketrans hello_str.translate hello_str.isalpha hello_str.partition hello_str.upper hello_str.isdecimal hello_str.replace hello_str.zfill hello_str.isdigit hello_str.rfind
提示:正是因为 python 内置提供的方法足够多,才使得在开发时,能够针对字符串进行更加灵活的操作!应对更多的开发需求!
1) 判断类型 - 9
方法 | 说明 |
---|---|
string.isspace() | 如果 string 中只包含空格,则返回 True |
string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True |
string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True |
string.isdecimal() | 如果 string 只包含数字则返回 True,全角数字 |
string.isdigit() | 如果 string 只包含数字则返回 True,全角数字 、⑴ 、\u00b2 |
string.isnumeric() | 如果 string 只包含数字则返回 True,全角数字 ,汉字数字 |
string.istitle() | 如果 string 是标题化的(每个单词的首字母大写)则返回 True |
string.islower() | 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True |
string.isupper() | 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True |
2) 查找和替换 - 7
方法 | 说明 |
---|---|
string.startswith(str) | 检查字符串是否是以 str 开头,是则返回 True |
string.endswith(str) | 检查字符串是否是以 str 结束,是则返回 True |
string.find(str, start=0, end=len(string)) | 检测 str 是否包含在 string 中,如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是返回开始的索引值,否则返回 -1 |
string.rfind(str, start=0, end=len(string)) | 类似于 find(),不过是从右边开始查找 |
string.index(str, start=0, end=len(string)) | 跟 find() 方法类似,不过如果 str 不在 string 会报错 |
string.rindex(str, start=0, end=len(string)) | 类似于 index(),不过是从右边开始 |
string.replace(old_str, new_str, num=string.count(old)) | 把 string 中的 old_str 替换成 new_str,如果 num 指定,则替换不超过 num 次 |
3) 大小写转换 - 5
方法 | 说明 |
---|---|
string.capitalize() | 把字符串的第一个字符大写 |
string.title() | 把字符串的每个单词首字母大写 |
string.lower() | 转换 string 中所有大写字符为小写 |
string.upper() | 转换 string 中的小写字母为大写 |
string.swapcase() | 翻转 string 中的大小写 |
4) 文本对齐 - 3
方法 | 说明 |
---|---|
string.ljust(width) | 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
string.rjust(width) | 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
string.center(width) | 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
center默认使用英文的空格,视觉上居中。
5) 去除空白字符 - 3
方法 | 说明 |
---|---|
string.lstrip() | 截掉 string 左边(开始)的空白字符 |
string.rstrip() | 截掉 string 右边(末尾)的空白字符 |
string.strip() | 截掉 string 左右两边的空白字符 |
这样就会居中了。
6) 拆分和连接 - 5
方法 | 说明 |
---|---|
string.partition(str) | 把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面) |
string.rpartition(str) | 类似于 partition() 方法,不过是从右边开始查找 |
string.split(str="", num) | 以 str 为分隔符拆分 string,如果 num 有指定值,则仅分隔 num + 1 个子字符串,str 默认包含 '\r', '\t', '\n' 和空格 |
string.splitlines() | 按照行('\r', '\n', '\r\n')分隔,返回一个包含各行作为元素的列表 |
string.join(seq) | 以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
4.3 字符串的切片
-
切片 方法适用于 字符串、列表、元组
-
切片 使用 索引值 来限定范围,从一个大的 字符串 中 切出 小的 字符串
-
列表 和 元组 都是 有序 的集合,都能够 通过索引值 获取到对应的数据
-
字典 是一个 无序 的集合,是使用 键值对 保存数据
-
字符串[开始索引:结束索引:步长]
注意:
-
指定的区间属于 左闭右开 型
[开始索引, 结束索引)
=>开始索引 >= 范围 < 结束索引
-
从
起始
位开始,到结束
位的前一位 结束(不包含结束位本身)
-
-
从头开始,开始索引 数字可以省略,冒号不能省略
-
到末尾结束,结束索引 数字可以省略,冒号不能省略
-
步长默认为
1
,如果连续切片,数字和冒号都可以省略
索引的顺序和倒序
-
在 Python 中不仅支持 顺序索引,同时还支持 倒序索引
-
所谓倒序索引就是 从右向左 计算索引
-
最右边的索引值是 -1,依次递减
-
演练需求
-
-
截取从 2 ~ 5 位置 的字符串
-
-
-
截取从 2 ~
末尾
的字符串
-
-
-
截取从
开始
~ 5 位置 的字符串
-
-
-
截取完整的字符串
-
-
-
从开始位置,每隔一个字符截取字符串
-
-
-
从索引 1 开始,每隔一个取一个
-
-
-
截取从 2 ~
末尾 - 1
的字符串
-
-
-
截取字符串末尾两个字符
-
-
-
字符串的逆序(面试题)
-
答案
num_str = "0123456789"
# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 从开始位置,每隔一个字符截取字符串
print(num_str[::2])
# 6. 从索引 1 开始,每隔一个取一个
print(num_str[1::2])
# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
# 9. 字符串的逆序(面试题)
print(num_str[::-1])
tuple 也是一种 list,唯一区别是 tuple 不可变。因此, tuple 也可以用切片操作,只是操作的结果仍是 tuple
05. 公共方法
5.1 Python 内置函数
Python 包含了以下内置函数:
函数 | 描述 | 备注 |
---|---|---|
len(item) | 计算容器中元素个数 | |
del(item) | 删除变量 | del 有两种方式 |
max(item) | 返回容器中元素最大值 | 如果是字典,只针对 key 比较 |
min(item) | 返回容器中元素最小值 | 如果是字典,只针对 key 比较 |
cmp(item1, item2) | 比较两个值,-1 小于/0 相等/1 大于 | Python 3.x 取消了 cmp 函数 |
注意
-
字符串 比较符合以下规则: "0" < "A" < "a"
5.2 切片
描述 | Python 表达式 | 结果 | 支持的数据类型 |
---|---|---|---|
切片 | "0123456789"[::-2] | "97531" | 字符串、列表、元组 |
-
切片 使用 索引值 来限定范围,从一个大的 字符串 中 切出 小的 字符串
-
列表 和 元组 都是 有序 的集合,都能够 通过索引值 获取到对应的数据
-
字典 是一个 无序 的集合,是使用 键值对 保存数据,字典中没有索引值的概念
5.3 运算符
运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
---|---|---|---|---|
+ | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
* | ["Hi!"] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 | 字符串、列表、元组 |
in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典 |
not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典 |
> >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比较 | 字符串、列表、元组 |
注意
-
in
在对 字典 操作时,判断的是 字典的键 -
in
和not in
被称为 成员运算符
成员运算符
成员运算符用于 测试 序列中是否包含指定的 成员
运算符 | 描述 | 实例 |
---|---|---|
in | 如果在指定的序列中找到值返回 True,否则返回 False | 3 in (1, 2, 3) 返回 True |
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False | 3 not in (1, 2, 3) 返回 False |
注意:在对 字典 操作时,判断的是 字典的键
加号会产生一个新列表,extend不会产生新的列表。
5.4 完整的 for 循环语法
-
在
Python
中完整的for 循环
的语法如下:
for 变量 in 集合:
循环体代码
else:
没有通过 break 退出循环,循环结束后,会执行的代码
应用场景
-
在 迭代遍历 嵌套的数据类型时,例如 一个列表包含了多个字典
-
需求:要判断 某一个字典中 是否存在 指定的 值
-
如果 存在,提示并且退出循环
-
如果 不存在,在 循环整体结束 后,希望 得到一个统一的提示
-
students = [
{"name": "阿土",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 75.0},
{"name": "小美",
"age": 19,
"gender": False,
"height": 1.6,
"weight": 45.0},
]
find_name = "阿土"
for stu_dict in students:
print(stu_dict)
# 判断当前遍历的字典中姓名是否为find_name
if stu_dict["name"] == find_name:
print("找到了")
# 如果已经找到,直接退出循环,就不需要再对后续的数据进行比较
break
else:
print("没有找到")
print("循环结束")