02 python 基础知识点 (容器部分+字符串)

第6章 容器类型的数据

Python内置的数据类型如序列（列表、元组等 ）、集合、字典等可以容纳多项数据，我们称它们为容器类型的数据。

6.1 序列简介

序列（sequence）是一种可迭代的、元素有序的容器类型的数据。

包括列表（list）、字符串（str）、元组（tuple）、字节序列（bytes）等。

6.1.1 序列的索引操作

序列中的元素都是有序的，每一个元素都带有序号，这个序号叫作索引。索引有正值索引、负值索引之分，正值索引为左到右，从（0 一> N-1）(比如单词)。

list= [1, 2, 2, 4]
len(list)    # len()  用于获取序列的长度

6.1.2 加和乘操作

加（+）和乘（*）运算符也可以用于序列中的元素操作。加（+）运算符可以将两个序列连接起来，乘（*）运算符可以将两个序列重复多次。

6.1.3 切片操作

序列的切片（Slicing）就是从序列中切分出小的子序列。

lst = [1, 2, 3, 6, 2]
lst[0:2]     # [1, 2]    # 使用“冒号”做切片操作   
'''切片运算符的语法形式为[start：end：step].   其中，start是开始索引，
end是结束索引，step是步长.
切片时获取的元素的间隔，可以为正整数(0开始)，也可以为负整数，反向切片时
列表顺序会进行颠倒, 步长设置为-1时,元素顺序会颠倒.
切下的小切片包括start位置的元素，但不包括end位置的元素.'''

6.1.4 成员测试

成员测试运算符有两个：in、not in，in用于测试是否包含某一个元素，not in用于测试是否不包含某一个元素。

6.2 列表

列表（list）是一种可变序列类型，我们可以追加、插入、删除、替换列表中的元素。

6.2.1 创建列表

创建列表有四种方法:

# list（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）
list1 = list([10,20,30,10,20,50])  
# [元素1，元素2，元素3，⋯]：指定具体的列表元素，元素之间以逗号分隔。 
list2 = [10,20,30,10,20,50]         
[i*i for i in range( a , b )]       # 列表的生成公式
lst = [],   lst1 = list()           # 空列表的创建

6.2.2 追加元素

列表是可变的序列对象，列表可以追加元素。

lst = [1, 2, 5, 3]
lst.append(4)  # 在列表中追加单个元素时，可以使用列表的append（x）方法。   
lst += [6, 7]  # 在列表中追加多个元素时，可以使用加(+)运算符或列表的extend()方法。
lst.extend([8, 9])   # 结果:[1, 2, 5, 3, 4, 6, 7, 8, 9]

6.2.3 插入元素(insert)

lst = [1, 2, 5, 3]  # 想向列表中插入元素时，可以使用列表的list.insert（i，x）方法.
lst.insert(1, 9)    # 结果: [1, 9, 2, 5, 3]  其中，i指定索引位置，x是要插入的元素.

6.2.4 替换元素

# 想替换列表中的元素时，将列表下标索引元素放在赋值符号（=）左边，进行赋值即可.
lst = [1, 2, 5, 3]  
lst[2] = 100        # 结果: [1, 2, 100, 3]

6.2.5 删除元素

remove(), pop(), del().

# 想在列表中删除元素时，可使用列表的list.remove（x）方法，如果找到匹配的元素x，则删除该元素.
lst = [1, 2, 5, 3, 2]   
lst.remove(2)  # 结果: [1, 5, 3, 2]  # 如果找到多个匹配的元素，则只删除第一个匹配的元素.
lst.pop(2)     # 结果: [1, 5, 2]  # X.pop() 根据索引移除元素，移除的某个位置的元素.
lst[1:2] = []  # 结果: [1, 2]     # 用切片的方式进行替换.
del(lst)       # 结果: name 'lst' is not defined  # del()命令，直接删除列表.

6.2.6 查询元素位置

index(), find().

lst = [1, 2, 5, 3, 2]  # index() 可以查询元素的位置.
lst.index(5)   # 结果: 2  # 列表不可以使用find函数进行查询，字符串可以用 find 和 index
'''如果有多个元素只能输出第一个元素的位置,
可以在指定区间查找, index中可以指定start 和 stop'''

6.2.7 列表元素的排序操作

lst = [1, 2, 5, 3, 2]
lst.sort(cmp=None, key=None, reverse=False)  # 语法  [1, 2, 2, 3, 5]
'''参数解析:
cmp ：可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key ： 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，
       指定可迭代对象中的一个元素.
reverse ：排序规则，reverse = True 降序， reverse = False 升序（默认）'''

# 调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变    
new_list = sorted(lst,reverse = True)    # [5, 3, 2, 2, 1]  

# 可以通过关键字进行排序

6.2.8 获取列表中的元素

lst = [1, 2, 5, 3, 2]
lst[1: 4]        # 正向索引  从0到 N-1   # [2, 5, 3]
lst[-3: -1]      # 逆向索引 从-N 到-1    # [5, 3]
lst[-1: -4: -1]  # 获取反向列表       # [2, 3, 5]
lst[3]    # 获取某个列表某个位置的值的方法，直接在后面加上[]及其位置  # 结果: 3

6.3 元组

元组（tuple）是一种不可变序列类型，不可以执行替换操作。

6.3.1 创建元组

创建元组时有两种方法:

# tuple（iter）函数：参数iterable是可迭代对象（字符串、列表、元组、集合...等）(双括号)
tup=tuple(('python','world',36))   
# （元素1，元素2，元素3，⋯）：指定具体的元组元素，可以使用小括号括起来，也可以省略小括号
tup = (1, 2, 3, 5)  
# 只包含一个元组的元素需要使用逗号和小括号, 没有逗号时直接会将元组内部值赋值给变量 
tup = ('python',)   
print(type(tup))    # type() 查看变量类型  # <class 'tuple'>
t1 = ()             # 空元组的两种创建方式
t2 = tuple()

6.3.2 元组拆包

创建元组，并将多个数据放到元组中，这个过程被称为元组打包,
与元组打包相反的操作是拆包，就是将元组中的元素取出，分别赋值给不同的变量。

a,b,c,d=1,2,3,4     # 解包赋值,

6.3.3 元组的遍历

tup = (1, 2, 5, 3, 2)    # enumerate: 枚举
for i in tup:            # 可以使用for循环进行遍历
'''enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
同时列出数据和数据下标，一般用在for循环当中,enumerate()是python的内置函数'''
for index,item in enumerate(coffee_name):    # 前面的index为输出的序号

6.4 集合

集合（set）是一种可迭代的、无序的、不能包含重复元素的容器类型的数据。

6.4.1 创建集合

# set（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）
set_1 = set([1, 2, 4, 5])    
# {元素1，元素2，⋯}：指定具体的集合元素，以逗号分隔。对于集合元素，需要使用大括号括起来。
set_1 = {1, 2, 3, 5}         
set_1 = set()     # 空集合的创建   
{i*i for i in range(a, b)}   # 集合的生成公式

6.4.2 修改集合

修改集合类似于修改列表，可以向其中插入和删除元素。修改可变集合有如右所示的常用方法。

add(), updata(), remove(), discard(), pop(), clear(), del()

set_1 = {1, 2, 3, 5}
# 集合的新增操作：# add（elem）：添加元素，如果元素已经存在，则不能添加，不会抛出错误。 
set_1.add(9)       # {1, 2, 3, 5, 9}
set_1.update({4, 6, 8})  # update( )：添加多个元素   # {1, 2, 3, 4, 5, 6, 8, 9}
# remove（elem）：删除元素，如果元素不存在，则抛出错误。  
set_1.remove(4)    # {1, 2, 3, 5, 6, 8, 9}
# discard：一次删除一个指定元素，如果指定的元素不存在不抛异常  
set_1.discard(5)   # {1, 2, 3, 6, 8, 9}
print(len(set_1))  # 可以使用len()统计集合内部元素的多少    # 6
set_1.pop()     # pop( )：一次只删除一个任意元素     # {2, 3, 6, 8, 9}
set_1.clear()   # 清除集合。   # set()
del(set_1)      # 可以使用del 进行删除集合

集合之间的数学操作：

s1 = {1, 2, 3, 5}
s2 = {2, 3, 4, 6}
print(s1.intersection(s2))  # 求两个集合的交集 print(s1 & s2)  # {2, 3}
print(s1.union(s2))         # 求两个集合的并集 print(s1 | s2)  # {1, 2, 3, 4, 5, 6}
print(s1.difference(s2))    # print(s2 - s1) 求两个集合的差集  # {1, 5}
print(s1.symmetric_difference(s2))  # 求集合对称差集, print(s1 ^ s2) # {1, 4, 5, 6}

6.4.3 判断操作

in / not in          # 判断集合中是否存在该元素

6.4.4 集合间的关系

s1 = {2, 4}
s2 = {2, 3, 4, 6}
# 一个集合是否是另一个集合的子集，可以调用方法issubset进行判断  
print(s2.issubset(s1))    # False  
# 一个集合是否是另一个集合的超集，可以调用方法issuperset进行判断
print(s2.issuperset(s1))  # True   
# 两个集合是否没有交集，可以调用方法isdisjoint进行判断   
print(s2.isdisjoint(s1))  # False    

6.4.5 set集合

基本特点：(1) 无序性   (2) 确定性    (3) 不重复性.
set( ) 实质：内部进行 可迭代性的 for 循环.
在python3中按数据类型的可变与不可变大致分为如下几种类型:

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

python中，用set来表示一个无序不重复元素的序列。set的主要作用就是用来给数据去重。
可以使用大括号 { } 或者 set() 函数创建集合，但是注意如果创建一个空集合必须用 set() 而不是 { }，因为{}是用来表示空字典类型的.

6.5 字典

字典（dict）是可迭代的、通过键（key）来访问元素的可变的容器类型的数据，字典是一个无序的序列。
字典由两部分视图构成：键视图和值视图。键视图（key，类似索引,可以只含数字）不能包含重复的元素，值视图能（values 类似存储空间）。在键视图中，键和值是成对出现的。
字典、列表、集合都是可以增、删、改的可变序列，元组为不可变序列。

6.5.1 创建字典

dic = dict(name='jack',age = 20)  # dict()函数   # {'name': 'jack', 'age': 20}
# 指定具体的字典键值对，键值对之间以逗号分隔，最后用大括号括起来。
dic =  {'key1':'value1', 'key2': 'value2'}  
dic = {}      # dict   空字典的创建 , 设置为集合需要 set1 = set({})
dic = dict()  # dict

6.5.2 修改字典

字典可以被修改，但都是针对键和值同时操作的，对字典的修改包括添加、替换和删除。

scores['张三'] = 63     # 通过'[]'进行新增操作，如果已存在就执行修改动作
scores.pop('王麻子')    # 使用字典中”pop”的方法删除
scores.clear()         # 通过‘clear’清空字典
del scores['张三']     # 通过‘del’命令进行删除某元素，同时删除其键和值  

6.5.3 访问字典视图

我们可以通过字典中的三种方法访问字典视图。

items(), keys(), values()

scores = {'李四': 30, '张三': 90}
# items()：返回字典的所有键值对视图。
items = scores.items()       # dict_items([('李四', 30), ('张三', 90)])
keys = list(scores.keys())   # keys()：返回字典键视图。   # ['李四', '张三']
values = scores.values()     # values()：返回字典值视图。   # dict_values([30, 90])

6.5.4 获取字典中的元素

scores = {'李四': 30, '张三': 90}
print(scores['李四'])   # []如果字典中不存在指定的key，抛出keyError异常。  # 30
# get()方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，
# 可以通过参数设置默认的value（如举例里的96），以便指定的key不存在时返回。   
print(scores.get('王六',96))     # 96
# 通过‘in’和‘not in’判断是否存在该元素，只会对前面的键进行判断，与后面的值无关
print('张三' in scores)  # True  

6.5.5 字典元素的遍历

scores = {'李四': 30, '张三': 90}
print(scores['李四'])   # print(scores.get(items))  # 输出字典的'values'值  # 30
print(scores.keys())    # 输出字典的 'key'值, items是关键字列表

6.5.6 字典生成第三种方式

dic = zip(items,prices)     # 内置函数 ‘zip’
b = {items:prices for items,prices in zip(items, prices)}    # 方式二

---

第7章 字符串

eval()      # 将“input”输入的函数直接转换为真实的数据类型
round(a,x)  # 数学函数进行四舍五入，其中a是对象，x是四舍五入保留小数，count()统计元素数量
count()     # 函数, 统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置 
str.count("char", start,end)  # 或 str.count("char")    # --> int   返回整数     

7.1 字符串的表示方式

7.1.1 普通字符串

• 普通字符串指用单引号（'）或双引号（＂）括起来的字符串。
• 常用的转义符如下:
  •  转义字符:   (\)   (r'')
  • 换行:\n                             #  直接跳行
  • 回车:\r                             #  会对原始值进行覆盖
  • 水平制表符 : \t                #  中间留空格
  • 退格 :\b                           #  删除
  • 反斜杠 :\\
  • 单引号:\'                          # 如果需要单独输出 ’ 可以在前面加 \ 进行输出
  • 双引号: \“

7.1.2 原始字符串

前面加上  r '  '  不会被转译。

7.1.3 长字符串

如果要使用字符串表示一篇文章，其中包含了换行、缩进等排版字符，则可以使用长字符串表示。对于长字符串，要使用三个单引号（'''或三个双引号（＂＂＂）括起来。

7.1.4 字符串的拼接

在需要进行字符串拼接时建议使用 str类型的join方法，而非+ ,因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高。

7.2 字符串与数字的相互转换

7.2.1 将字符串转换为数字

将字符串转换为数字，可以使用int（）和float（ ）实现，如果成功则返回数字，否则引发异常。

在默认情况下，int（）函数都将字符串参数当作十进制数字进行转换，int（）函数也可以指定基数（进制）。

7.2.2 将数字转换为字符串

将数字转换为字符串，可以使用str( )函数，str( )函数可以将很多类型的数据都转换为字符串。

7.3 格式化字符串

7.3.1 格式化字符串

格式化字符串的两种方式：

• %作占位符    （%s表示字符串占位   ，%i / %d 表示整数占位，%f 表示浮点数值占位）    举例：print('我叫%s，今年%d岁' % (name,age))           #  后面为多个元素时记得加（）
• 表示其精度和宽度：print('%10.3f'   %    3.14526)       #  一共宽度 10，小数点后 3 位
• format方式，{ }作占位符        其中大括号内部数值表示引用后方元组的序号        举例： print('我叫{0}，今年{1}岁'.format(name,age))               
  • 表示其精度和宽度：print('{1:3.3f}，爱你'.format(1335（输出未调用该值）,3.2545621))       # 前边的1 表示索引的的位置 注意有冒号 10.3f表示显示一共显示10位，三位小数
  • 其二:用于填充格式化 如'{0:*>10}'.format(9)        #  右对齐 这种模式用法有三种,:[填充字符][对齐方式 <^>][宽度]
    • a.冒号后面接的是选用的填充字符, 如上面用的是*号
    • b.<^> 指定三种不同的对齐方式, 可简单理解为看箭头指向方向为对齐的方向
    • c.对齐方向后面是宽度, 如上面的右对齐的宽度是10
    • d.指定的内容一定需要用"{}"括起来,而且必须是从0开始,或者可以把0去掉(此处待研究)
    • 上面的显示结果是:输出9,按照10位宽度右对齐方式,也就是左边用9位"*"代替      # 输出：*********9
• 使用f-string       举例： print(f'我叫{name},今年{age}岁')
  • f-string采用 {content:format} 设置字符串格式，其中 content 是替换并填入字符串的内容，可以是变量、表达式或函数等，format 是格式描述符。采用默认格式时不必指定 {:format}，如上面例子所示只写 {content} 即可            #  print(f'{i:*>2}')    *为占位符
• 格式化字符串：

for i in range(1,30):
    print (str(i).rjust(2,'0'))     # 输出两位格式化，如1自动补充为“01”

7.4 操作字符串

7.4.1 编码的转换     

GBK转换：

• byte = s.encode(encoding='GBK')               # 编码，s 为源文件
• print(byte.decode(encoding='GBK'))           # 解码

UTF-8转换：

• byte = s.encode(encoding='UTF-8')            # 编码，s 为源文件
• print(byte.decode(encoding='UTF-8'))         # 解码

7.4.2 字符串的查询命令

s = 'loader'
print(s.index('lo'))      # 查询元素第一次出现的位置，如果不存在该元素即报错
# 查询元素第一次出现的位置，如果不存在该元素输出‘-1’     # 推荐使用“find”命令
print(s.find('lo'))        
print(s.rindex('lo'))     # 查询元素最后一次出现的位置，如果不存在该元素即报错 
print(s.rfind('lo'))      # 查询元素最后一次出现的位置，如果不存在该元素输出‘-1

7.4.3 字符串的大小写转换

• upper()              # 全部转换为大写          # 举例： a = s.upper()
• lower()              #  全部转换为小写         # 举例： a = s.lower()
• swapcase()       # 大小写进行相互转换
• capitalize()        # 第一个字符大写，其余全部进行小写
• title()                 # 每个单词的第一个字符大写，其余全部小写

7.4.4 字符串内容对其的操作

字符串调整: str(i).rjust(2,'0').

• center()         # 居中对其       # 可以设置全体宽度和填充物    
• ljust()            # 左对齐           # left 左
• rjust()           # 右对齐           # print (str(i).rjust(2,'0'))
• zfill()            # 右对齐           # 不可以指定填充物，默认为‘0’进行填充 

7.4.5 字符串的劈分操作

• split()    # 举例：print(s1.split(sep=',', maxsplit=2))      #  默认从左到右执行劈分操作，返回值为列表，通过参数 “sep”可以指定劈分符，通过参数“maxsplit”可以指定最大劈分数量.    
• rsplit()   # 从右向左开始劈分.

7.4.6 判断字符串的操作

• isidentifier()     # 判断是否合法
• isspace()         # 判断是否全部为空白字符
• isalpha()          # 判断是否全为字母
• isdecimal()      # 判断是否全部为十进制数值
• isnumeric()      # 判断是否全部为数字组成
• isalnum()         # 判断是否全部由字母和数字组成，可以只含数字或字母
• isdigit()            # 检测字符串是否只由数字组成，只对0和正数有效，负数判定为False。    # 举例： if X.isdigit()  （二进制？）
• endswith         # 判断以什么结尾.     举例：if item.endswith('.py'): 就怎么怎么样

7.4.7 字符串的其他操作

• replace()          # 替换字符串中的元素         举例：print(s1.replace('python','Java',2))       (前面一个字符是被替换掉的部分，最后的数值为需要替换的数量，默认为全部替换)
• join()                # 将列表、元组中的字符串合并       举例：print('\t'.join(lst))     (前面为分隔符，后面为元组）

7.4.8 字符串的比较操作

• 两个字符进行比较时，比较的是其ordinal value(原始值),调用内置函数ord可以 得到指定字符的ordinal value。与内置函数ord( ) （其他数据类型转换为数值）对应的是内置函数chr( ) （其他数据类型转换为字母），调用内置函数chr时指定ordinal value可以得到其对应的字符.
• >,>=,<,<=,==,!=

7.4.9 字符串的切片操作

• 切片操作完整公式 [start:stop:step]         # 举例：print(s[1:5:1])     # 正负号表示显示正反方向，正数从前往后，负数从后向前，颠倒原字符串顺序     # 前边位置的正负只限制其位置，不管其顺序.

7.4.10 Python中的 join( )方法

• join( )是一个字符串方法。
• sep 是分隔符。
• 语法：'sep'.join(sep_object)。
• 用法：连接任意数量的字符串（包括要连接的元素字符串、元组、列表、字典），用新的目标分隔符连接，返回新的字符串。
• 返回值： join()方法返回一个被子字符串连接的字符串。
• Type Error: 报错, 如果这个可迭代元素包含任何不是字符串的值，join()函数就会抛出TypeError。

c={'hello':1,'world':2}
'*'.join(c)   # 'hello*world'
d = ['hello', 'hi', 'world', '2']
'\\'.join(d)  # 'hello\\hi\\world\\2'

7.4.11 strip( )方法的使用

• Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
• 注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。