Python 基础知识

Python语言基础

Python语法特点

注释

单行注释
# 作为单行注释符号，从 # 开始直到换行为止，其后面所有的内容都作为注释的内容而被 Python 编译器忽略

多行注释

'''
注释内容1
注释内容2
'''
# 或者
"""
注释内容1
注释内容2
"""

中文注释

#codeing=编码
#-*-coding:编码-*-

编码为文件所使用的字符编码类型，有 utf-8 、gbk、cp936

代码缩进

Python程序设计语言采用 代码缩进 和冒号 : 区分代码间的层次，行尾的冒号和下一行的缩进表示一个代码块的开始，而缩进结束，则表示一个代码块的结束。

编码规范

编写规则
1.每个 import 语句只导入一个模块
2.不要在行尾添加分号 :，也不要用分号将两条命令放在同一行
3.建议每行不超过 80 个字符，如果超过建议使用 () 将多行内容隐式连接起来
4.使用必要的空行增加代码的可读性
5.运算符两侧、函数参数之间、逗号 “,” 两侧建议使用空格进行分隔
6.避免在循环中使用 + 和 += 操作符累加字符串。因为字符串是不可变的，这样会创建不必要的临时对象
7.适当使用异常处理结构提高程序容错性

命名规范
1.模块名尽量短小，并且全部使用小写字母，可以使用下划线分隔多个字母，game_main、bmiex 都是推荐使用的模块名称
2.包名尽量短小，并且全部使用小写字母，不推荐使用下划线，com.mr.book、com.mr 都是推荐使用的包名
3.类名采用单词首字母大写形式
4.模块内部的类采用下划线 _ + Pascal 风格的类名组成。例如：BorrowBook 类中的内部类，可以使用 _BorrowBook 命名
5.函数、类的属性和方法的命名规则同模块类似，也是全部采用小写字母，多个字母间用下划线分隔
6.常量命名时采用全部大写字母，可以使用下划线
7.使用单下划线开头的模块变量或者函数是受保护的
8.使用双下划线开头的实例变量或方法是类私有的

变量

保留字与标识符

Python 中的保留字是系统留用的，命名函数、变量、类、模块和其它对象的名称不可以使用
查看关键字的命令语句

import keyword
keyword.kwlist

标识符命名规则
1.由字母、下划线和数字组成，并且第一个字符不能是数字，字符只允许使用 A ~ Z 和 a ~ z
2.不能使用 Python 中的保留字
3.区分大小写
4.Python 中下划线开头的标识符有特殊意义
以单下划线开头的标识符不能直接访问的类属性
以双下划线开头的标识符表示类的私有成员
以双下划线开头和结尾的是 Python 里专用的标识，int() 表示构造函数

Python 语言允许使用汉字作为标识符，但是强烈建议不采取此做法！！！

变量

Python 中的变量就是名字、标签；命名慎用小写字母 l 和大写字母 O

# 语法格式 变量名 = value
nickname = "Edviv"
# type() 返回变量类型
print(type(nickname))
# id() 获取变量内存地址
print(id(nickname))

常量就是程序运行过程中 值不能改变的量，但是实际开发过程中，常量首次赋值后，还是可以被其他代码修改

基本数据类型

数字

Python 中，提供数字类型用于保存这些数值，并且是不可改变的数据类型；如果修改数字类型变量的值，那么会先把该值存放到内容中，然后修改变量让其指向新的内存地址

整数： 包括正整数、负整数 和 0；当超过计算机自身的计算功能时，会自动转用高精度计算

八进制数整数：0o 或 0O
十六进制整数：0x 或 0X

浮点数： 整数和小数部分组成
str(a) 函数将数值 a 转换成字符串

复数： 虚部使用 J 或 j 表示，表示一个复数实部和虚部相加；3.14+1.5j 实部 3.14；虚部 1.5j

字符串

字符串： 就是连续的字符序列，可以是计算机所能表示的一切字符的集合，字符串属于不可变序列，通常使用 ‘’、" “、”“” “”"、‘’’ ‘’'

# 在字符串定界符引号的前面加上字母 r 或 R,该字符原样输出
print("失望之酒\x0a机会之杯")
# 失望之酒
# 机会之杯
print(r"失望之酒\x0a机会之杯")
# 失望之酒\x0a机会之杯
print(R"失望之酒\x0a机会之杯")
# 失望之酒\x0a机会之杯

布尔类型

Python 中，标识符号 True 和 False 被解释为布尔值，True 表示 1，而 False 表示 0

数据类型转换

数字 ===> 字符串 ===> int(x) ===> 字符串 ===> 输出

函数	作用
int(x)	将x转换成整数类型
float(x)	将x转换成浮点数类型
complex(real[,imag])	创建一个复数
str(x)	将x转换为字符串
repr(x)	将x转换为表达式字符串
eval(str)	计算在字符串中的有效Python表达式，并返回一个对象
chr(x)	将x转换为一个字符
ord(x)	将一个字符x转换为它对应的整数值
hex(x)	将一个整数x转换为一个十六进制的字符串
otc(x)	将一个整数x转换为一个八进制的字符串

基本输入输出

input()函数输入

使用内置函数 input() 接收用户键盘输入的内容，在 Python3.x中无论输入的是数字还是字符都被视作为字符串读取，想要得到想要的数据类型，需要进行数据类型转换

print() 函数输出

基本语法格式： print(输出内容)
在 Python 中，默认情况下，一条 print() 语句输出会自动换行，如果想输出多个内容且不换行，可以将要输出的内容使用英文半角的逗号分隔

运算符与表达式

运算符

算术运算符

运算符	说明
+	加
-	减
*	乘
/	除
%	求余
//	取整数
**	幂
使用 % 求余，如果第二个操作数是负数，结果是负数；使用 / 或 // 除数不能为 0，否则将会出现异常。Python 3.x 中 7/2=3.5，Python 2.x 中 7/2=3

赋值运算符

= 右边的值赋值给左边的变量

比较关系运算符

运算符	作用
>	大于
<	小于
==	等于
!=	不等于
>=	大于等于
<=	小于等于

逻辑运算符

运算符	含义
and	逻辑与
or	逻辑或
not	逻辑非

位运算符

& ( 按位与 ) ：两个操作数对应位置的二进制位都是 1 时。结果才是 1，否则结果是 0，精度与精度高的操作数相同

| (按位或 )：两个操作数对应位置的二进制位都是 0 时。结果才是 0，否则结果是 1，精度与精度高的操作数相同

^ ( 按位异或 )：两个操作数对应位置的二进制位不同。结果才是 1，否则结果是 0，精度与精度高的操作数相同

~ ( 按位取反 )：将操作数对应二进制中的 1 修改成 0，0 修改成 1

<< ( 左移位运算符 )：将一个二进制操作数向左移动指定的位数，左边溢出的位被舍弃，右端的空位补 0，左移运算符相当于乘以 $2^n$

>> ( 右移位运算符 )：将一个二进制操作数向右移动指定的位数，右端溢出位被舍弃，该操作数是负数时左边补 1，该操作数是正数时左边补 0

运算符优先级

类型	说明
**	幂
~、+、-	取反、正号、负号
*、/ 、%、//	算术运算符
+、-	算术运算符
<<、>>	位移运算符中的左移和右移
&	按位与
^	按位异或
|	按位或
<、<=、>、>=、!=、==	比较运算符
优先级从上到下降低

条件表达式

a = 10
b = 6
if a > b:
    r = a
else :
    r = b
# 等价
a = 10
b = 6
r = a if a > b else b
# 如果 a > b 为 True，则返回 r = a，否则返回 r = b

流程控制语句

程序结构： 顺序结构、选择结构、循环结构

选择语句

Python 中没有 switch 语句， if 表达式的值为非 0 的数或者非空的字符串时认为条件成立
最简单的 if 语句

if 表达式:
    语句块

if … else 语句

if 表达式:
    语句块1
else
    语句块2
# 等价下面
语句1 if 表达式 else 语句2

if … elif … else 语句

if 表达式1:
    语句块1
elif 表达式2:
    语句块2
elif 表达式3:
    语句块3
...
else:
    语句块 n

循环语句

Python 中无 do … while 循环
while 循环

while 条件表达式:
    循环体

for 循环

for 迭代变量 in 对象:
    循环体

range(start, end, step)
start： 用于指定计数的起始值，如果省略则从 0 开始
end： 指定计数的结束值，不可省略，range(7) 得到的值为 0 ~ 6
step： 用于两个数之间的间隔，如果省略，步长为 1

range()： 如果只有一个参数，则表示 end，如果有两个参数，则表示指定的是 start 和 end，只有 3 个参数都存在时，最后一个才表示 step

Python 3.x： 输出一行内容

# print(i, end = '分隔符')
for i in range(50):
    if(i%3 == 2 and i%5 == 3):
        print(i, end = ' ')

break、continue、pass 语句

break 语句： 结束本次循环
continue 语句： 结束本次内循环
pass 语句： 不做任何事情，起到占位作用

列表与元组

序列

索引

序列结构主要有： 列表、元组、集合、字典、字符串
集合和字典不支持索引、切片、相加和相乘操作

正数索引

元素	元素1	元素2	元素…	元素 n
索引下标	0	1	…	n - 1

负数索引

元素	元素1	元素2	元素…	元素 n
索引下标	- ( n - 1)	-( n - 2 )	…	- 1

切片

# 切片操作可以生成一个新的序列
# 语法格式
sname[start: end : step]
# sname: 序列的名称
# start: 切片开始的位置,包括该位置,未指定则默认 0
# end: 表示切片的截止位置,不包括该位置,未指定则默认序列长度
# step: 表示切片的步长,如省略,则默认为 1
# sname[ : ] 表示复制整个序列

序列相加

Python 中支持两种相同类型的序列相加，即使用 + 运算符实现连接操作，相同类型的序列是指同为列表、元组、字符串等，序列中的元素类型可不同

乘法

使用一个 n 乘以一个序列会得到一个新的序列，新序列的内容是原来序列被重复 n 次的结果

in 检查某个元素是否是序列的成员

value in sequence
# value 要检查的元素
# sequence 表示指定的序列
# not in 检查某个元素是否不包含在序列中

内置函数

函数	说明
list()	将序列转换为列表
str()	将序列转换为字符串
sum()	计数元素和
sorted()	对元素进行排序
reversed()	反向序列中的元素
enumerate()	将序列组合成为一个索引序列
len()	计数序列的长度
max()	返回序列中的最大元素
min()	返回序列中的最小值

列表

列表创建删除

= 将一个列表赋值给变量

listname = [ element1, element2, ... ,element n]
# listname 表示列表的名称
# element1 ... elementn 表示列表中的元素,个数无限制 

创建空列表

emptylist = []

创建数值列表

list(range(10, 20, 2))

删除列表

del listname

实际开发中，Python 自带垃圾回收机制会自动销毁不用的列表，即使未手动删除，Python 也会自动将其回收

datetime.datetime.now() 方法获取当前日期，weekday() 方法则是从日期时间对象中获取星期，值为 0 ~ 6 中的其中的一个

遍历列表

for 循环只能输出元素的值，enumerate() 结合使用可同时输出索引值和元素内容

for item in listname:
    # 输出 item

for index, item in enumerate(listname)
    # 输出 index 和 item

# index: 用于保存元素的索引
# item: 用于保存获取到的元素值
# listname: 列表名称

列表添加修改删除

+ 或者 append() 方法： 通过该方法实现列表添加元素

listname.append(obj)
# 在列表末尾添加元素

extend： 将一个列表中的全部元素添加到另一个列表中

# 将 seq 的内容追加到 listname 中
listname.extend(seq)
# listname 原列表
# seq 添加的列表

列表中的元素只需要通过索引获取该元素，然后再为其重新赋值即可

del： 根据索引删除
remove(value)： 根据元素值删除列表中所有和 value 一样的元素

列表计算

count() 方法： 判断指定元素出现的次数

listname.count(obj)
# listname 列表名称
# obj 表示要判断是否存在的对象

index()方法： 获取指定元素在列表中首次出现的位置

listname.index(obj)
# listname: 表示列表名称
# obj: 表示要查找的对象,如果对象不存在,则抛出异常
# 返回值: 首次出现的索引值

sum()函数： 统计数值列表中各元素的和

sum(iterable[:])
# iterable: 表示要统计的列表
# [ : ] 如果未指定,默认是 0开始

列表排序

sort()方法： 对原序列表中的元素进行排序，排序后原列表中的元素顺序将发生改变，对于中文支持不好

listname.sort(key=None, reverse=False)
# listname: 表示进行排序的列表
# key: 表示指定一个从每个列表元素中提取一个比较键
# key=str.lower 在排序时不区分字母大小写
# reverse: 指定为 True 表示降序排列, 指定为 False表示升序排序,默认升序

sorted()函数： 对列表进行排序，原序列的元素顺序不变。

sorted(iterable, key = None, reverse = False)
# iterable:表示要进行排序的序列
# key:表示指定从每个元素中提取一个用于比较的键盘
# key = str.lower 表示在排序时不区分大小写
# reverse: 指定为 True,表示降序排列;指定为 False,表示升序排列,默认升序

列表推导式

生成指定范围的数值列表

# list=[Expression for var in range]
# list: 表示生成的列表名称
# Expression: 表达式,用于计算新列表的元素
# var: 循环变量
# range: 采用 range() 函数生成的 range 对象
# 随机生成 10 个 [10, 100] 之间的数
import random
randomnumber = [random.randint(10,100) for i in range(10)]
print(randomnumber)

生成指定需求的列表

# newlist = [Expression for var in list]
# newlist: 表示新生成的列表名称
# Expression: 表达式,用于计算新列表的元素
# var: 变量
# list: 用于生成新列表的原列表
ago = [10, 20]
now = [x*2 for x in ago]
print(ago)
print(now)

列表中选择符合条件的元素组成新的列表

# newlist = [Expression for var in list if condition]
# newlist: 表示新生成的列表名称
# Expression: 表达式,用于计算新列表的元素
# var: 变量,值为后面列表的每个元素
# list: 用于生成新列表的原列表
# condition: 条件表达式, 用于指定筛选条件
ago = [10, 20]
now = [x for x in ago if x > 15]
print(ago)
print(now)

二维列表

import random
arr = []           #创建一个空列表
for i in range(5): # 5 行
    arr.append([]) # 在空列表中再添加一个空列表
    for j in range(3):
        arr[i].append(random.randint(1,5)) # 内层列表添加元素

for i in range(5): # 输出列表
    print(arr[i])

列表推导式创建

# 创建 4 行 5 列的二维列表
arr = [[j for j in range(5)] for i in range(4)]
# 可用于 listname[下标1][下标2] 访问
# listname: 表示列表名称
# 下标1: 表示列表中第几行,下标值从 0 开始
# 下标2: 表示列表中第几列,下标值从 0 开始

元组

元组( tuple )： 是不可变序列，在形式上，元组的所有元素都放在一对小括号 () 中，两个相邻元素之间使用 , 分隔；在内容上可以将整数、实数、字符串、列表、元组等任何类型的内容放入元组中,同一个元组中，元素的类型可以不同，因为它们之间没有任何关系，元组用于保存程序中不可修改的内容

元组操作

将一组值用逗号分隔开来，Python 就可以认为它是元组
创建空元组

emptytuple = ()

空元组可以应用在为函数传递一个空值或者返回空值

创建数值元组

# tuple(data)
# data 表示可以转换为元组的数据
# data 类型可以是 range 对象、字符串、元组或者其他可迭代类型的数据

删除元组

# del tuplename
# tumplename: 表示要删除元组的名称

del 语句在实际开发时并不常用， Python 自带的垃圾回收机制会自动销毁不用的元组
访问元组元素
采用切片方式获取指定元素

arr = tuple(range(1,20,2))
print(arr[:3])

enumerate()函数： 将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标

nowarr = ("Edviv","Lily","Bob","Tom","Hily","Cboy")
for index, item in enumerate(nowarr):
    if index%3 == 0 and index:
        print()                     # 输出换行
        print(item + " ", end = " ")
    else:
        print(item + " ", end = " ")

元组是不可变序列，不能对它的单个元素值进行修改，但是可以进行重新赋值；元组进行连接时，连接的内容必须都是元组

元组推导式

使用元组推导式生成的结果并不是一个元组或者列表，而是一个生成器对象；_next_()： 的方法输出每个元素，再将生成器对象转换成元组输出；无论采取哪种方法遍历，如果再使用该生成器对象，都必须重新创建一个生成器对象，因为遍历后，原生成器对象已经不存在

import random   # 导入 random 标准库
ago = (random.randint(10,50) for i in range(5)) # 生成生成器对象
print(ago.__next__()) # 输出第一个元素
now = tuple(ago)  # 转换为元组
print(now)

元组与列表的区别

元组和列表都属于序列，而且都可以按照特定顺序存放一组元素，类型不受限制

列表和元组的区别：
1.列表属于可变序列，它的元素可以随时修改或者删除；元组属于不可变序列，其中的元素不可以修改，除非整体替换
2.列表可以使用 append()、extend()、insert()、remove()、pop() 等方法实现添加和修改列表元素，而元组则没有这几个方法，因为不能向元组中添加和修改元素，也不能删除元素
3.列表可以使用切片访问和修改列表中的元素；元组也支持切片，但是它只支持通过切片访问元组中的元素，不支持修改
4.元组比列表的访问和处理速度快；如果只需要对其中的元素进行访问，而不进行任何修改，建议使用元组
5.列表不能作为字典的键，而元组可以

字典与集合

字典

字典主要特征： 类似 C/C++、Java 中的 Map
1.通过键而不是通过索引来读取
2.字典是任意对象的无序集合
3.字典是可变的，并且可以任意嵌套
4.字典中的键必须唯一，如果出现多次，最后一个值被记住
5.字典中的键必须不可变，所以可使用数字、字符串或者元组，但不能使用列表
字典的创建：

# dictionary = {'key1':'value1','key2':'value2',...,'keyn':'valuen',}
# dictionary: 表示字典名称
# key1, ..., keyn: 表示元素的键,必须是唯一的,并且不可变
# value1, ..., valuen: 表示元素的值, 可以是任何数据类型, 不是必须唯一

创建空字典：
dictionary = {} 或者 dictionary = dict()

通过映射函数创建字典：

# dictionary = dict(zip(list1, list2))
# dictionary: 表示字典名称
# zip()函数: 用于将多个列表或元组对应位置的元素组合为元组, 并返回包含这些内容的 zip 对象
# list1: 表示一个列表, 用于指定要生成字典的键
# list2: 表示一个列表, 用于指定要生成字典的值、
key = ['Edviv', 'Bob', 'Tom']  # 作为键的列表
age = ['23', '24', '19']       # 作为值的列表
Map = dict(zip(key, age))      # 转换为字典
print(Map)                     # 输出转换后字典

键-值对创建字典：

# dictionary = dict(key1 = value1, ..., keyn = valuen)
# dictionary: 表示字典名称
# key1, ..., keyn: 表示元素的键, 必须是唯一的, 并且是不可变
# value1, ..., valuen: 表示元素的值, 可以是任何数据类型
dictionary = dict(Edviv = '22', Bob = '20')
print(dictionary)

fromkeys()方法： 创建值为空的字典

# dictionary = dict.fromkeys(list1)
# dictionary: 表示字典名称
# list1: 作为字典的键的列表
list1 = ['Edviv', 'Bob']
dictionary = dict.fromkeys(list1)
print(dictionary)

del dictionary 删除字典
dictionary.clear() 清空字典的全部元素
dictionary.get()方法： 获取指定键的值

遍历字典：
items()方法： 获取字典的 “键-值对” 列表

list1 = ['Edviv', 'Bob']
list2 = ['22', '20']
dictionary = dict(zip(list1,list2))
for item in dictionary.items():
    print(item)
# 具体的每个键 和 值
for key, value in dictionary.items():
    print(key, value)

字典中添加元素：dictionary[key] = value
dictionary： 表示字典名称
key： 添加元素的键，必须唯一且不可变
value： 表示元素的值

字典推导式

import random
randomdict = {i : random.randint(1,10) for i in range(1,4)}
print(randomdict)

name = ['Edviv','Bob','Tom']        # 键的列表
sign = ['双子座', '水瓶座', '射手座'] # 值的列表
nowdictionary = {i:j for i, j in zip(name, sign)}
print(nowdictionary)

集合

集合分为 set 和 frozenset
{} 创建集合

# setname = {element1, ...,elementn}
# setname 表示集合的名称
# element1, ...,elementn 表示集合中的元素, 个数无限制
set1 = {1, 3, 5, 7, 9, 4, 0, 0, 1}
print(set1)
# 创建集合输入重复的元素, 只会保留一个

set()函数 将列表、元组等可迭代对象转换为集合

# setname = set(iteration)
# setname: 表示集合名称
# iteration: 表示要转换为集合的可迭代对象, 可以是列表、元组、range对象等
# 返回不重复的集合
set2 = set([1, 5, 4, 6])
print(set2)

在创建空集合，只能使用 set() 实现，而不能使用一对大括号 “{}”，因为在 Python 中使用 “{}” 创建的是一个空字典，所以创建集合使用 set() 函数

向集合中添加元素

# setname.add(element)
# setname: 表示添加元素的集合
# element: 表示要添加的元素内容,只能使用字符串、数字及布尔类型等
# 不能使用 列表、元组等可迭代对象

setname.pop()： 删除一个元素
setname.clear()： 清空集合
setname.remove(iteration)： 删除指定元素

set2 = set([1, 5, 4, 6]) # 创建集合
print(set2)
set2.add(10)            # 添加一个元素
print(set2)
set2.pop()              # 删除一个元素
print(set2)
set2.remove(10)        # 删除指定元素
print(set2)
set2.clear()           # 清空集合
print(set2)

&： 两个集合进行交集运算
|： 两个集合进行并集运算
- ： 两个集合进行差集运算
^ ： 两个集合进行差集运算

字符串

str 表示 Unicode 字符
bytes 表示二进制数据

字符串编码转换

encode()方法： 为 str 对象的方法，用于将字符串转换为二进制数据(即 bytes) “编码”

# str.encode([encoding="utf-8"][,errors="strict"])
# str: 表示要进行转换的字符串
"""
 encoding="utf-8": 可选参数,用于指定进行转码时采用的字符编码,默认UTF-8,使用简体中文可以设置gb2312,
 只有一个参数,可以省略前面的"encoding=",直接编码
"""

"""
errors="strict": 可选参数,用于指定错误处理方式,其可选择值 strict 遇
到非法字符就抛出异常、ignore 忽略非法字符、replace 用 ? 替换非法字符
或 xmlcharrefreplace 使用 XML 的字符引用等,默认值为 strict
"""

decode()： 为 bytes 对象的方法，用于将二进制数据转换为字符串，“解码”

# bytes.decode([encoding="utf-8"][,errors="strict"])
# bytes: 表示要进行转换的二进制数据
"""
 encoding="utf-8": 可选参数,用于指定进行解码时采用的字符编码,默认UTF-8,使用简体中文可以设置gb2312
 只有一个参数,可以省略前面的"encoding=",直接写编码
"""

"""
errors="strict": 可选参数,用于指定错误处理方式,其可选择值 strict 遇
到非法字符就抛出异常、ignore 忽略非法字符、replace 用 ? 替换非法字符
或 xmlcharrefreplace 使用 XML 的字符引用等,默认值为 strict
"""

verse = "我是Edviv"
byte = verse.encode('utf-8') # 编码
print(verse)                 # 原码
print(byte)                  # 二进制数据
print(byte.decode("UTF-8"))  # 解码

字符串常用操作

+ 运算符可完成对多个字符串的拼接并产生一个字符串对象
len()函数： 计算字符串的长度时，不区分英文、数字和汉字，所以字符都认为是一个
采用 UTF-8 编码，汉字占 3 个字节；采用 GBK 或 GB2312 时，汉字占 2 个字节；Python 中，数字、英文、小数点、下划线和空格占一个字节
截取字符串

# string[start : end : step]
# string: 表示要截取的字符串
# start: 表示要截取的第一个字符的索引,如果不指定,默认为0
# end: 表示要截取的最后一个字符的索引,不包括该字符,如果不指定,则默认字符串的长度
# step: 表示切片的步长,如果省略,则默认为1

split()： 把一个字符串按照指定的分隔符切分为字符串列表，该列表的元素中，不包括分隔符

# str.split(seq, maxsplit)
# str: 表示要进行分割的字符串
# seq: 指定分隔符,可以包含多个字符,默认为None,即所有空字符
'''
maxsplit: 可选参数,用于指定分割次数,如果不指定或者为-1,则分隔次数没有限制
否则返回结果列表的元素个数最多为 maxsplit + 1
'''
# 返回值: 分割后的字符串列表

split()： 如果不指定参数，默认采用空白符进行分割，这时无论有几个空格或者空白符都将作为一个分割符进行分割
合并字符串

# strnew = string.join(iterable)
# strnew: 表示合并后生成的新字符串
# string: 字符串类型,用于指定合并时的分隔符
# iterable: 可迭代对象,该迭代对象中的所有元素将被合并为一个新的字符串
# string 作为边界点分割出来

检索字符串
count()： 检索指定字符串在另一个字符串中出现的次数，如果检索的字符串不存在，则返回 0，否则返回出现的次数

# str.count(sub[ ,start[ ,end]])
# str: 表示原字符串
# sub: 表示要检索的子字符串
# start: 可选参数,表示检索范围的起始位置的索引,如果不指定,则从头开始检索
# end: 可选参数,表示检索范围的结束位置的索引,如果不指定,则一直检索到结尾

find()方法： 检索是否包含指定的子字符串；如果检索的字符串不存在，则返回 -1，否则返回首次出现该子字符串时的索引

# str.find(sub[ ,start[ ,end]])
# str: 表示原字符串
# sub: 表示要检索的子字符串
# start: 可选参数,表示检索范围的起始位置的索引,如果不指定,则从头开始检索
# end: 可选参数,表示检索范围的结束位置的索引,如果不指定,则一直检索到结尾

index()方法： 用于检索是否包含指定的子字符串，当指定的字符串不存在时会抛出异常

# str.index(sub[ ,start[ ,end]])
# str: 表示原字符串
# sub: 表示要检索的子字符串
# start: 可选参数,表示检索范围的起始位置的索引,如果不指定,则从头开始检索
# end: 可选参数,表示检索范围的结束位置的索引,如果不指定,则一直检索到结尾

startswith()方法： 检索字符串是否以指定子字符串开头；如果是则返回 True，否则返回 False

# str.startswith(prefix[ ,end]])
# str: 表示原字符串
# prefix: 表示要检索的子字符串
# start: 可选参数,表示检索范围的起始位置的索引,如果不指定,则从头开始检索
# end: 可选参数,表示检索范围的结束位置的索引,如果不指定,则一直检索到结尾

endswith()： 检索字符串是否以指定子字符串结尾；如果是则返回 True，否则返回 False

# str.endswith(suffix[ ,start[ ,end]])
# str: 表示原字符串
# suffix: 表示要检索的子字符串
# start: 可选参数,表示检索范围的起始位置的索引,如果不指定,则从头开始检索
# end: 可选参数,表示检索范围的结束位置的索引,如果不指定,则一直检索到结尾

str.lower()： 将 str 中的全部大写字母转换为小写字母
str.upper()： 将 str 中的全部小写字母转换为大写字母

去除字符串中的空格和特殊字符

strip()方法： 用于去掉左、右两侧的空格和特殊字符

# str.strip([chars])
# str: 为要去除空格的字符串
'''
chars: 可选参数,用于指定要去除的字符,可以指定多个
如果不指定 chars 参数,默认将去除空格、制表符\t、回车符\r、换行符\n等
'''

lstrip()方法： 用于去掉字符串左侧的空格和特殊字符串

# str.lstrip([chars])
# str: 为要去除空格的字符串
'''
chars: 可选参数,用于指定要去除的字符,可以指定多个
如果不指定 chars 参数,默认将去除空格、制表符\t、回车符\r、换行符\n等
'''

rstrip()方法： 用于去掉字符串右侧的空格和特殊字符

# str.rstrip([chars])
# str: 为要去除空格的字符串
'''
chars: 可选参数,用于指定要去除的字符,可以指定多个
如果不指定 chars 参数,默认将去除空格、制表符\t、回车符\r、换行符\n等
'''

格式化字符串

格式化字符串的意思是先制定一个模板，在这个模板中预留几个空位，然后再根据需要填上相应的内容，这些空位需要通过指定的符号标记，而这些符号还不会显示出来

在 Python 中，要实现格式化字符串，可以使用 % 操作符；%[-][+][0][m][.n]格式化字符%exp
-： 可选参数，用于指定左对齐，正数前方无符号，负数前面加负号
+： 可选参数，用于指定右对齐，正数前方加正号，负数前方加负号
0： 可选参数，表示右对齐，正数前方元符号，负数前方加负号，用 0 填充空白处 ( 一般与 m 参数一起使用)
m： 可选参数，表示占有宽度
.n： 可选参数，表示小数点后保留的位数
格式化字符： 用于指定类型

常用的格式化字符

格式字符	说明	格式字符	说明
%s	字符串(采用str()显示)	%r	字符串(采用repr()显示)
%c	单个字符	%o	八进制整数
%d 或 %i	十进制整数	%e	指数(基底写为e)
%x	十六进制整数	%E	指数(基底写为E)
%f 或 %F	浮点数	%%	字符%

format()方法： 用于字符串格式化

'''
str.format(args)
str: 用于指定字符串的显示样式
args: 用于指定要转换的项,如果有多项,则用逗号进行分隔
创建模板时,需要使用 {} 和 : 指定占位符
{[index][:[[fill]align][sign][#][width][.precision][type]]}
index: 可选参数,用于指定要设置格式的对象在参数列表中的索引位置,索引值从0开始,如果省略则根据值的先后顺序自动分配
fill: 可选参数,用于指定空白处填充的字符

align: 可选参数,用于指定对齐方式;值为 < 表示内容左对齐; 值为 > 表示内容右对齐; 值为 = 表示内容右对齐,将符号放
在填充内容的最左侧,且只对数字类型有效; 值为 ^ 表示内容居中,需要配合 width 一起使用

sign: 可选参数,用于指定有无符号数;值为 + 表示正数加正号,负数加负号; 值为 - 表示正数不变,负数加负号;值为空格表
示正数加空格,负数加负号

#: 可选参数,对于二进制、八进制和十六进制,如果加上 #,表示会显示 0b/0o/0x 前缀,否则不显示前缀
width: 可选参数,用于指定所占宽度
.precision: 可选参数,用于指定保留的小数位数
type: 可选参数,用于指定类型
'''

formcat()方法中常用的格式化字符

格式字符	说明	格式字符	说明
S	对字符串类型格式化	b	将十进制整数自动转换成二进制表示再格式化
D	十进制整数	o	将十进制整数自动转化成八进制表示再格式化
C	将十进制整数自动转化成对应的 Unicode 字符	x 或 X	将十进制整数自动转化成十六进制表示再格式化
e 或 E	转化为科学记数法表示再格式化	f 或 F	转化为浮点数(默认小数点后保留6位)再格式化
g或 G	自动在 e 和 f 或者 E 和 F 中切换	%	显示百分比(默认显示小数点后6位)