前言
print(" _ooOoo_ ")
print(" o8888888o ")
print(" 88 . 88 ")
print(" (| -_- |) ")
print(" O\\ = /O ")
print(" ____/`---‘\\____ ")
print(" . ‘ \\| |// `. ")
print(" / \\||| : |||// \\ ")
print(" / _||||| -:- |||||- \\ ")
print(" | | \\\\\\ - /// | | ")
print(" | \\_| ‘‘\\---/‘‘ | | ")
print(" \\ .-\\__ `-` ___/-. / ")
print(" ___`. .‘ /--.--\\ `. . __ ")
print(" ."" ‘< `.___\\_<|>_/___.‘ >‘"". ")
print(" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
print(" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
print(" ======`-.____`-.___\\_____/___.-`____.-‘====== ")
print(" `=---=‘ " )
print(" ")
print(" ............................................. ")
print(" 佛祖镇楼 国庆快乐 ")
字符串基础（String）
python中字符的定义使用单引号或者双引号都可以，例如：
str1="Hello" #或者 str2="Jonins"
注意：在python3中input获取键盘输入的数据，都以字符串的方式进行保存，即使输入的是数字。
下标&切片
1.下标
下标：可以理解为数组类数据类型内元素的索引。列表与元组支持下标索引，字符串是字符的数组，所以也支持下标索引。索引从0开始，而内存中实际存储如下：
2.切片
切片：是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。切片的语法格式如下：
1 变量名[起始:结束:步长]
注意：选取的区间属于左闭右开型，既从起始位开始，到结束位的前一位，不包含结束位本身。说明示例如下：
1 name=‘0123456789‘ 2 print(name[0:3])#取下标0-2的字符 3 print(name[3:5])#取下标3-4的字符 4 print(name[3:])#取下标3开始到最后的字符 5 print(name[3:-3])#取下标3开始到倒数第3个之间的字符（不包含倒数第三） 6 print(name[3:-1:2])#取标3开始到倒数第一个之间间隔为2-1的字符（步长，默认是1，当指定的时取值是步长的值，可以理解为中间间隔(步长-1)） 7 print(name[-1::-1])#倒叙输出字符串
列表基础（List）
1.列表基础
列表类型的格式：
1 testList=[xxx,yyy,zzz....nnn]
列表支持切片和下标操作，而python比C语言的数组强大的地方在于列表中的元素可以是不同类型的：
1 tuple=[‘jonins01‘,2,‘jonins02‘,3.3] 2 print(tuple[2]) 3 tuple2=tuple[0:2] 4 print(tuple2)
2.列表的遍历
为了更有效的输出列表的每个数据，可以使用循环来完成，列表的遍历可以使用for循环或者while循环来实现，示例如下：
1 nameList=[‘jonins1‘,‘jonins2‘,‘jonins‘] 2 print(‘-----for循环遍历-----‘) 3 for name in nameList: 4 print(name) 5 print(‘-----while循环遍历-----‘) 6 i=0 7 while i<len(nameList): 8 print(nameList[i]) 9 i+=1
元组基础（Tuple）
1.元组基础
python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。列表的格式如下：
1 tuple=(xxx,yyy,zzz....nnn)
python中不允许修改元组的数据，包括不能删除其中的元素。元组同样支持切片和下标操作。
1 tuple=(‘jonins1‘,2,‘jonins‘,3.3) 2 print(tuple[2]) 3 tuple2=tuple[0:] 4 print(tuple2)
2.元组的遍历
元组同样可以遍历，通过for循环和while循环都可以实现：
1 tuple=(‘jonins1‘,2,‘jonins‘,3.3) 2 print(‘-----for循环遍历-----‘) 3 for t in tuple: 4 print(t) 5 print(‘-----while循环遍历-----‘) 6 i=0 7 while i<len(tuple): 8 print(tuple[i]) 9 i+=1
字典基础（Dictionary）
1.字典基础
说明：字典是key/value键值对集合。字典和列表一样，都可以存储多个数据。列表中找某个元素是根据下标进行，而字典中找某个元素是根据key查找。字典的格式如下：
1 info={‘key1‘:value1,‘key2‘:value2,......‘keyn‘:valuen}
示例:
1 info={‘name‘:‘jonins‘,‘age‘:18,‘sex‘:‘man‘}
2 print(info[‘age‘])
注意：
1.字典的键（key）可以是任何不可变类型。但不可重复。
2.字典的值（value）可以是任何类型。
3.若访问不存在的键（key）则会报错。
2.字典的遍历
字典提供内置的方法keys()、values()、items()方法，可以根据需求做所需要的遍历操作，示例如下：
1 info={‘name‘:‘jonins‘,3:18,‘sex‘:‘man‘}
2 print(‘遍历字典的键（key）‘)
3 for key in info.keys():
4 print(key)
5 print(‘遍历字典的值（value）‘)
6 for value in info.values():
7 print(value)
8 print(‘遍历字典的项（元素）‘)
9 for item in info.items():
10 print(item)
字符串常用操作（String）
1.find&rfind
find() 方法检测字符串中是否包含子字符串 str ，如果指定 start（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
rfind()方法类似于find()方法，不过是从右边开始查找。
语法格式：
1 myStr.find(str,start,end)
说明:
myStr：指定检索的字符串。
str：检测的字符串或字符。
start：开始索引，默认为0。
end： 结束索引，默认为字符串的长度。
示例如下：
1 stringInfo = ‘hello my name is jonins‘ 2 result = stringInfo.find(‘my‘, 0, len(stringInfo)) 3 print(result)
2.index&rindex
跟find()方法一样，index()如果在检测字符或字符串不存在会报一个异常。
rindex()方法类似于index()，不过是从右边开始。
3.count
count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
语法格式：
1 myStr.count(str,start,end)
说明:
myStr：指定检索的字符串。
str：搜索的子字符串
start：字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end：字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
示例如下：
1 stringInfo = ‘hello my name is jonins‘ 2 result = stringInfo.count(‘m‘, 0, -1) 3 print(result)
4.replace
eplace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
语法格式：
1 myStr.replace(old, new[, max])
说明:
myStr：指定替换的字符串。
old：将被替换的子字符串。
new：新字符串，用于替换old子字符串。
max ：可选字符串, 替换不超过 max 次
示例如下：
1 stringInfo = ‘jonins jonins jonins jonins ‘ 2 stringInfo=stringInfo.replace(‘jonins‘,‘jon&ins‘, 2) 3 print(stringInfo)
5.split
split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串。返回分割后的字符串列表。
语法格式：
1 myStr.split(str, num)
说明:
myStr：指定分割的字符串。
str：分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num：分割次数。
示例如下：
1 stringInfo = ‘jonins jonins jonins jonins ‘ 2 stringInfoList=stringInfo.split(‘ ‘, 2) 3 print(stringInfoList)
6.capitalize
capitalize()方法将字符串的第一个字母变成大写,其他字母变小写。示例如下：
1 stringInfo = ‘jonins jonins jonins jonins ‘ 2 stringInfo=stringInfo.capitalize() 3 print(stringInfo)
7.title
title()方法返回"标题化"的字符串,所有单词的首个字母转化为大写，其余字母均为小写。示例如下：
1 stringInfo = ‘jonins jonins jonins jonins ‘ 2 stringInfo=stringInfo.title() 3 print(stringInfo)
8.startswith&endswith
startswith()方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 start 和 end 指定值，则在指定范围内检查。
endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。如果参数 start 和 end 指定值，则在指定范围内检查。
语法格式：
1 myStr.startswith(str, start,end)#检测指定开始 2 myStr.endswith(str, start,end)#检测指定结尾
说明：
myStr：指定检索的字符串。
str：该参数可以是一个字符串或者是一个元素。
start：字符串中的开始位置。
end：字符中结束位置。
示例如下：
1 stringInfo = ‘hello jonins‘ 2 startFlag=stringInfo.startswith(‘hel‘) 3 endFlag=stringInfo.endswith(‘ins‘) 4 print(startFlag) 5 print(endFlag)
9.lower&upper
lower()方法转换字符串中所有大写字符为小写。
upper()方法将字符串中的小写字母转为大写字母。
示例如下：
1 stringInfo = ‘heLlO jOnInS‘ 2 lowerStr=stringInfo.lower() 3 upperStr=stringInfo.upper() 4 print(lowerStr) 5 print(upperStr)
10.ljust&rjust¢er
ljust()方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
rjust()方法返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
center()方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
语法格式：
1 myStr.ljust(width,fillchar) 2 myStr.rjust(width,fillchar) 3 myStr.center(width,fillchar)
说明：
myStr：指定需对齐的字符串。
width：指定字符串长度。
fillchar：填充字符，默认为空格。
示例如下：
1 stringInfo = ‘jonins‘ 2 ljustStr=stringInfo.ljust(10)#左对齐 3 rjustStr=stringInfo.rjust(10)#右对齐 4 centerStr=stringInfo.center(10)#居中 5 print(‘-%s-‘%ljustStr) 6 print(‘-%s-‘%rjustStr) 7 print(‘-%s-‘%centerStr)
11.lstrip&rstrip&strip
lstrip()方法用于截掉字符串左边的空格或指定字符（默认为空格）。
rstrip()方法用于删除字符串末尾的指定字符（默认为空格）。
strip()方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
语法格式：
1 myStr.lstrip(chars)#删除左边的某字符 2 myStr.rstrip(chars)#删除右边的某字符 3 myStr.strip(chars)#删除两端的某字符
说明：
myStr：指定检索的字符串。
chars：指定移除的字符。
示例如下：
1 myStr = ‘ jonins ‘ 2 lstripStr=myStr.lstrip() 3 rstripStr=myStr.rstrip() 4 stripStr=myStr.strip() 5 print(‘-%s-‘%lstripStr) 6 print(‘-%s-‘%rstripStr) 7 print(‘-%s-‘%stripStr)
12.partition&rpartition
partition()方法用来根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
rpartition()方法类似于partition()，不过是从右开始。示例如下：
1 myStr = ‘my name is jonins‘ 2 strTuple=myStr.partition(‘name‘) 3 print(strTuple)
13.splitlines
splitlines()方法按照行(‘\r‘, ‘\r\n‘, \n‘)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
语法格式：
1 myStr.splitlines([keepends])
说明：
myStr：指定分割的字符串。
keepends ：默认为 False，不包含换行符，如果为 True，则保留换行符。
示例如下：
1 myStr = ‘hello \n jonins‘ 2 strList=myStr.splitlines() 3 print(strList)
14.isalpha&isdigit&isalnum&isspace
isalpha()方法检测字符串是否只由字母组成。
isdigit()方法检测字符串是否只由数字组成。
isalnum()方法检测字符串是否由字母和数字组成。
isspace()方法检测字符串是否只由空白字符组成
示例如下：
1 isalphaStr=‘abcd‘.isalpha()#判断是否只有字母 2 isdigitStr=‘1234‘.isdigit()#判断是否只有数字 3 isalnumStr=‘a1b2c3‘.isalnum()#判断是否只有字母和字母 4 isspaceStr=‘ ‘.isspace()#判断是否只有空白字符 5 print(isalphaStr) 6 print(isdigitStr) 7 print(isalnumStr) 8 print(isspaceStr)
15.join
join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
语法格式：
1 str.join(sequence)
说明：
str：指定连接的字符。
sequence：要连接的元素序列。
示例如下：
1 strList=[‘my‘,‘name‘,‘is‘,‘jonins‘] 2 str=‘ ‘ 3 stringInfo=str.join(strList) 4 print(stringInfo)
列表常用操作（List）
1.添加元素（append&extend&insert）
append()方法用于在列表末尾添加新的对象。
extend()函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
insert()函数用于将指定对象插入列表的指定位置。
示例如下：
1 A=[‘1‘,‘2‘,‘3‘,‘4‘] 2 A.append(‘5‘)#尾部追加一个元素 3 print(A) 4 B=[‘101‘,‘102‘,‘103‘] 5 B.extend(A)#尾部追加一个集合 6 print(B) 7 B.insert(2,‘INSERT‘)#在下标2处追加元素 8 print(B)
2.修改元素
修改元素的时候，要通过下标来确认要修改那个元素，然后才能进行修改，示例如下：
1 A=[‘1‘,‘2‘,‘3‘,‘4‘] 2 A[0]=‘01‘ 3 print(A)
3.查找元素（in¬ in&index&count）
可以使用python运算符（in、not in）来判断列表是否存在指定的元素，示例及说明如下：
in（包含）:如果存在那么结果为Ture,否则为False。
not in（不包含）:如果不存在那么结果为Ture,否则为False。
1 A=[‘1‘,‘2‘,‘3‘,‘4‘] 2 flag1=‘2‘ in A 3 flag2=‘2‘ not in A 4 print(flag1) 5 print(flag2)
也可以使用python提供的index和count方法实现检测，具体使用方式与字符串中使用index和count方法的用法相同，示例及说明如下：
index()方法用于从列表中找出某个值第一个匹配项的索引位置。
count()方法用于统计某个元素在列表中出现的次数。
1 A=[‘1‘,‘2‘,‘3‘,‘4‘] 2 flag1=A.index(‘3‘) 3 flag2=A.count(‘3‘) 4 print(flag1) 5 print(flag2)
4.删除元素（del&pop&remove）
del：根据下标进行删除。
pop：删除最后一个元素。
remove：根据元素的值进行删除。
示例如下：
1 A=[‘1‘,‘2‘,‘3‘,‘4‘,‘5‘] 2 del A[0]#根据下标删除元素 3 A.pop()#删除最后一个元素 4 A.remove(‘3‘)#根据元素值删除元素 5 print(A)
5.排序（sort&reverse）
sort() 方法用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。而reverse()方法用于反向列表中元素（逆置）。
语法格式：
1 list.sort(cmp=None, key=None, reverse=False)
说明：
cmp：可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse：排序规则，reverse = True 降序， reverse = False 升序（默认）。
示例如下：
1 A=[‘1‘,‘2‘,‘5‘,‘4‘,‘3‘] 2 A.reverse()#列表逆置 3 print(A) 4 A.sort()#列表升序排序 5 print(A) 6 A.sort(reverse=True)#列表降序排序 7 print(A)
元组常用操作（Tuple）
元组内置的函数index和count，它们的用法与字符串和列表中的用法相同。
字典常用操作（Dictionary）
1.修改元素
字典中的每个元素只要通过key（键）找到，即可修改。示例：
1 info={‘name‘:‘jonins‘,‘age‘:‘18‘}
2 info[‘age‘]=‘20‘
3 print(info)
2.添加元素
当指定key（键）来访问元素时若该键不存，则会报错。如果要添加元素，可以使用：
1 变量名[‘键‘]=数据
的方式，当键不存在时，就会新增这个元素。示例如下：
1 info={‘name‘:‘jonins‘,‘age‘:‘18‘}
2 info[‘id‘]=‘1001‘
3 print(info)
3.删除元素（del&clear）
del可以删除指定的元素，也可删除整个字典，删除整个字典后不允许访问字典，否则会报错。
clear()方法可以清空整个字典，允许清口后访问字典。
示例如下：
1 infoA={‘name‘:‘jonins‘,‘age‘:‘18‘,‘id‘:‘1001‘,‘sex‘:‘man‘}
2 infoB={‘name‘:‘jonins‘,‘age‘:‘18‘,‘id‘:‘1001‘,‘sex‘:‘man‘}
3 del infoA[‘id‘]
4 print(infoA)
5 del infoA#删除后，不能访问，否则会报错
6 infoB.clear();
7 print(infoB)
4.判断键（in¬ in）
可以使用python运算符（in、not in）来判断key（键）是否存在，示例及说明如下：
in（包含）:如果存在那么结果为Ture,否则为False。
not in（不包含）:如果不存在那么结果为Ture,否则为False。
1 info={‘name‘:‘jonins‘,‘age‘:‘18‘,‘id‘:‘1001‘,‘sex‘:‘man‘}
2 print(‘name‘ in info)
3 print(‘name‘ not in info)
5.其它内置及常用函数
len()方法用于测量字典中的键值对个数。
keys()方法返回一个包含字典所有key（键）的列表。
values()方法返回一个包含字典所有value（值）的列表。
items()方法返回一个包含所有（key,value）元组的列表。
示例如下：
1 info={‘name‘:‘jonins‘,‘age‘:‘18‘,‘id‘:‘1001‘,‘sex‘:‘man‘}
2 print(len(info))
3 print(info.keys())
4 print(info.values())
5 print(info.items())
公共方法
运算符
注意：in和not in在对字典操作时，判断的是字典的key（键）。
内置函数
结语
若无特殊说明，文章内的示例和说明，默认适用于Python3并不一定兼容于Python2。
作者Python解释器为Python3.6版本。
原文地址：https://www.cnblogs.com/jonins/p/9724911.html