.1.字符串
使用双引号或者单引号中的数据，就是字符串.
注:python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
如：'''
得不到的
永远
在骚动
'''
在Python中字符串是可以反方向读取的
下标和切片
下标索引
所谓“下标”，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间
列表与元组支持下标索引, 字符串实际上就是字符的数组，所以也支持下标索引。
如果有字符串name = 'abcdef'
如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）
name = 'abcdef'
print(name[0]) -----a
print(name[1])------b
print(name[2])------c
切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长] 有方向(数值的正负)有区间
注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。
如果取出一部分，则可以在中括号[]中，使用:
name = 'abcdef'
print(name[0:3]) # 取 下标0~2 的字符
print(name[0:5]) # 取 下标为0~4 的字符
print(name[3:5]) # 取 下标为3、4 的字符
print(name[2:]) # 取 下标为2开始到最后的字符
print(name[1:-1]) # 取 下标为1开始 到 最后第2个之间的字符
print(name[:3])
print(name[::2])#步长为2，2个一组
eg12345 如果切出的不够一组，则将每组第一的取出：1 3 5
print(name[::-2])负数即为从右向左切
print(name[5:1:2])
print(name[5:1:-2]) fd
print(name[1:5:2])
如果起始为负数则从后向前数字符串内容，但是输出方向依旧是从左向右（终点数字遵循包前不包后原则）起始要从小向大写：
print(name[-5:-1]) 输出：bcde
要是从右向左切片步长为负需要从大向小写起始下标，反之亦然:
print(name[5:1:-2]) 输出：fd
字符串常见操作
Str='qwertyuioprwe'
Str='qwertyuioprwe'
<1>find print(str.find('w')) 1
检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
mystr.find(str, start=0, end=len(mystr))
<2>index不在其中报异常
跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
mystr.index(str, start=0, end=len(mystr))
<3>count print(str.count('w')) 2
返回 str在start和end之间 在 mystr里面出现的次数
mystr.count(str, start=0, end=len(mystr))
<4>replace替换函数print(str.replace('w','y'，1))1代表替换一次
把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
mystr.replace(str1, str2, mystr.count(str1))
Str=’aabcdefg’
<5>split * 将字符串转为了列表 另一种转列表的方式print(list('abcdefg'))
print(str.split(‘c’)) ['aab', 'defg'] 用, 的话每个字母用，隔开了
以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
mystr.split(str=" ", 2)
<6>capitalize
把字符串的第一个字符大写
mystr.capitalize()
<7>title
把字符串的每个单词首字母大写
mystr.title()
弊端：不会区分单词也不会识别单词，重要一个或多个字母在一起就会识别为一个单词
<8>startswith
检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False
mystr.startswith(obj)
<9>endswith
检查字符串是否以obj结束，如果是返回True,否则返回 False.
mystr.endswith(obj)
<10>lower
转换 mystr 中所有大写字符为小写
mystr.lower()
<11>upper
转换 mystr 中的小写字母为大写
mystr.upper()
<12>ljust
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
mystr.ljust(width)
<13>rjust
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
mystr.rjust(width)
<14>center print(str.center(70)) str不够空格补充
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
mystr.center(width)
<15>lstrip
删除 mystr 左边的空白字符
mystr.lstrip()
<16>rstrip 也可以这样删除右边的，print(',aa,'.rstrip(','))
删除 mystr 字符串末尾的空白字符
mystr.rstrip()
<17>strip
删除mystr字符串两端的空白字符
mystr.strip()
<18>rfind
类似于 find()函数，不过是从右边开始查找.
mystr.rfind(str, start=0,end=len(mystr) )
<19>rindex
类似于 index()，不过是从右边开始.
mystr.rindex( str, start=0,end=len(mystr))
<20>partition print(str.partition('t')) ('qwer', 't', 'yuioprwe')
把mystr以str分割成三部分,str前，str和str后
mystr.partition(str)
<21>rpartition
类似于 partition()函数,不过是从右边开始.
mystr.rpartition(str)
<22>splitlines
按照行分隔，返回一个包含各行作为元素的列表 一行一个
mystr.splitlines()
<23>isalpha
如果 mystr 所有字符都是字母 则返回 True,否则返回 False
mystr.isalpha()
<24>isdigit
如果 mystr 只包含数字则返回 True 否则返回 False.
mystr.isdigit()
<25>isalnum
如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
mystr.isalnum()
<26>isspace
如果 mystr 中只包含空格，则返回 True，否则返回 False.
mystr.isspace()
<27>join
用于将序列中的元素以指定的字符连接生成一个新 的字符串。
mystr.join(str)
2.列表
<1>列表的格式
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
<2>打印列表
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])
列表的循环遍历
1. 使用for循环
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
print(name)
2. 使用while循环
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(namesList)
i = 0
while i<length:
print(namesList[i])
i+=1
列表的相关操作
列表中存放的数据是可以进行修改的，比如"增"、"删"、"改""
（1）添加元素（“增”append，extend，insert）
append列表是一个整体添加，通过append可以向列表添加元素
demo：
#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----添加之前，列表A的数据-----")
for tempName in A:
print(tempName)
#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
A.append(temp)
print("-----添加之后，列表A的数据-----")
for tempName in A:
print(tempName)
extend
通过extend可以将另一个集合中的元素逐一添加到列表中
>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]
Insert lis1.insert（1，’小鸟’）在下标为1前插入
insert(index, object) 在指定位置index前插入元素object
>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]
<2>修改元素("改")
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改
demo:
#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----修改之前，列表A的数据-----")
for tempName in A:
print(tempName)
#修改元素
A[1] = 'xiaoLu'
print("-----修改之后，列表A的数据-----")
for tempName in A:
print(tempName)
<3>查找元素("查"in, not in, index, count)
所谓的查找，就是看看指定的元素是否存在
python中查找的常用方法为：print('xiaogou' in(list1))
in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false
demo
#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
#获取用户要查找的名字
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in nameList:
print('找到了相同的名字')
else:
print('没有找到')
说明：
in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在
index, count
index和count与字符串中的用法相同
>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
<4>删除元素("删"del, pop, remove)
列表元素的常用删除方法有：
del：根据下标进行删除
pop：删除最后一个元素
remove：根据元素的值进行删除
demo:(del)
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------')
for tempName in movieName:
print(tempName)
del movieName[2]
print('------删除之后------')
for tempName in movieName:
print(tempName)
demo:(pop)
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------')
for tempName in movieName:
print(tempName)
movieName.pop()
print('------删除之后------')
for tempName in movieName:
print(tempName)
demo:(remove)
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------')
for tempName in movieName:
print(tempName)
movieName.remove('指环王')
print('------删除之后------')
for tempName in movieName:
print(tempName)
<5>排序(sort, reverse)
lis_num = [2, 4, 1, 8, 7]
lis_num.sort() # 升序排序
print(lis_num)
lis_num.sort(reverse=True) # 降序排序
print(lis_num)
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
reverse方法是将list逆置。
>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]
列表的嵌套
类似while循环的嵌套，列表也是支持嵌套的
一个列表中的元素又是一个列表，那么这就是列表的嵌套
schoolNames = [['北京大学','清华大学'],
['南开大学','天津大学','天津师范大学'],
['山东大学','中国海洋大学']]
3.集合
集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合，重复的元素被自动去掉
# 成员测试
if('Rose' in student) :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素
4.元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)
<1>访问元组
tuple = ('hello',10,3.14)
print(tuple[0])
print(tuple[1])
print(tuple[2])
<2>修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
>>> tup1 = (12, 34.56)
>>> tup2 = ('abc', 'xyz')
>>> tup1[0] = 100
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
tup1[0] = 100
TypeError: 'tuple' object does not support item assignment
>>> tup3 = tup1 + tup2
>>> tup3
(12, 34.56, 'abc', 'xyz')
<3>删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup = ('Google', 'Runoob', 1997, 2000)
del tup;
print ("删除后的元组 tup : ")
print (tup)
5.字典
变量info为字典类型：
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
说明：
字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的
字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'、'id'、'sex'）
字典的每个元素由2部分组成，键:值。例如 'name':'班长' ,'name'为键，'班长'为值
<3>根据键访问值
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
print(info['name'])
print(info['address'])
结果:
班长
地球亚洲中国北京
若访问不存在的键，则会报错：
>>> info['age']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'age'
在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：
>>> age = info.get('age')
>>> age #'age'键不存在，所以age为None
>>> type(age)
<type 'NoneType'>
>>> age = info.get('age', 18) # 若info中不存在'age'这个键，就返回默认值18
>>> age
18
字典的常见操作1
<1>修改元素
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
demo:
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
newId = input('请输入新的学号')
info['id'] = int(newId)
print('修改之后的id为%d:'%info['id'])
<2>添加元素
dic1['height'] = 180 直接添加
demo:访问不存在的元素
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
print('id为:%d'%info['id'])
如果在使用 变量名['键'] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素
demo:添加新的元素
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
# print('id为:%d'%info['id'])#程序会终端运行，因为访问了不存在的键
newId = input('请输入新的学号')
info['id'] = newId
print('添加之后的id为:%d'%info['id'])
<3>删除元素
对字典进行删除操作，有一下几种：
del
clear()
demo:del删除指定的元素
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
print('删除前,%s'%info['name'])
del info['name']
print('删除后,%s'%info['name'])
demo:del删除整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s'%info)
del info
print('删除后,%s'%info)
demo:clear清空整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前,%s'%info)
info.clear()
print('清空后,%s'%info)
字典的常见操作2
<1>len()
返回字典中键值对的个数
<2>keys
返回一个包含字典所有KEY的可迭代对象
<3>values
返回一个包含字典所有value的可迭代对象
<4>items
返回一个包含所有（键，值）元组的可迭代对象
遍历
通过for ... in ...:的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构。
注意python语法的缩进
字符串遍历
a_str = "hello world"
for char in a_str:
print(char, end=' ')
列表遍历
a_list = [1, 2, 3, 4, 5]
for num in a_list:
print(num, end=' ')
元组遍历
a_turple = (1, 2, 3, 4, 5)
for num in a_turple:
print(num,end=" ")
字典遍历
<1> 遍历字典的key（键）
dict = {'name':1,'sex':'a'}
for key in dict.keys():
print(key)
<2> 遍历字典的value（值）
dict = {'name': 1, 'sex': 'a'}
for value in dict.values():
print(value)
<3> 遍历字典的项（元素）
dict = {'name':1,'sex':'a'}
for item in dict.items():
print(item)
<4> 遍历字典的key-value（键值对）
dict = {'name':1,'sex':'a'}
for key,value in dict.items():
print(key,value)
实现带下标索引的遍历
chars = ['a', 'b', 'c', 'd']
i = 0
for chr in chars:
print("%d %s" % (i, chr))
i += 1
enumerate() 函数
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
chars = ['a', 'b', 'c', 'd']
for i, chr in enumerate(chars):
print(i, chr)
6.公共方法
运算符
| 运算符 | 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 | 元素是否不存在 | 字符串、列表、元组、字典 |
+
>>> "hello " + "world"
'hello world'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')
*
>>> 'ab'*4'
ababab'
>>> [1, 2]*4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b')*4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
in
>>> 'he' in 'hello world
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True
>>> "name" in {"name":"Delron", "age":24}
True
注意，in在对字典操作时，判断的是字典的键
python内置函数
Python包含了以下内置函数
| 序号 | 方法 | 描述 |
| 1 | len(item) | 计算容器中元素个数 |
| 2 | max(item) | 返回容器中元素最大值 |
| 3 | min(item) | 返回容器中元素最小值 |
| 4 | del(item) | 删除变量 |
注:
range() 函数返回的是一个可迭代对象
range(stop)
range(start, stop[, step])
如：
range(5)
range(0, 5,1)
range(0, 5,2)
列表推导式
所谓的列表推导式，就是指的轻量级循环创建列表
a = [x for x in range(4)]
a = [x for x in range(1,4)]
a = [x for x in range(1,10) if x % 2 == 0]
a = [(x,y) for x in range(1,3) for y in range(3)]
7.引用
在python中，值是靠引用来传递来的。
我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。
可变类型与不可变类型:
可变类型，值可以改变
List（列表）、Dictionary（字典）、Set（集合）。
不可变类型，值不可以改变：
Number（数字）、String（字符串）、Tuple（元组）；
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
