Python基础知识（1）——字符串，列表，集合，元组，字典
先扯两句，本人因晚上睡不着觉，所以把Python中的语法归纳了一下，希望对大家有用。
哎，没办法被codeforces制裁到自闭mdzz（咕咕咕~~~）
emmmmmm现在开始喽2333——正题！！！
引子：
Python是面向对象的语言。Python一切数据皆为对象包含了一系列的数据和操作这些数据的方法的一个整体，就叫作对象。一切变量都是对数据对象的引用。（好像是这么说的吧，课本里的话计不得了2333~~~）
1.数据类型的组成:(分三部分)
地址： id方法来看一看他的唯一标示符，（内存地址）
类型 ：type
值： 数据
and then 在Python中，一切都是指针，所以不存在指针这个东东。
2. 常用基本数据类型：
int 整型（范围理论长度无限）float浮点，（没有double）
boolean 布尔（True与False）首字符必须大写
string 字符串
list 列表
tuple 元祖
dict 字典
3.数据类型改变值，id的变化：
不可变类型：int，string，tuple
eg：你可以令 a = 1然后再 a = 2，先后测一下a的id，你会发现它们是不一样的！
可变类型: list，dict
例如a = [1,2,3]，然后a.append(4),此时a=[1,2,3,4] ； but ，a的id值是不变的！！！
4.变量/常量~算术运算：
基本运算符（+，-，......），幂运算，整除,求余，调用数学函数（abs，sqrt...），强制运算符。
（不具体说看看书就好）
一.字符串：
1.拼接：
（1）在Python中字符串与字符串的拼接与C++一样用 ”+“ 就好（但是太消耗资源，小白才用）
（2）字符串模板：%s....%：
"cf too difficult,%s" % "I choose development"
"cf too difficult,%s%s" % ("I", " choose development")
//cf too difficult,I choose development其中，%s表示要插入字符串，叫做占位符；% 后面的字符表示要插入字符串的内容
占位符通常有2种，%s：字符串的占位符， %d：数字的占位符。（数字的插入用法与字符串的类似）
（3）join()：
a = "a"
b = "bc"
c = "2333"
d = "".join([a,b,c])
print(d)
//输出：abc2333使用join，先要把三个变量a，b，c合成一个list，才能用join()进行拼接，直接用join(a,b,c)报错，因为join()函数只能有一个参数
对与join函数这里做一个简单说明，'sep'.jion([a,b,c])，在拼接a,b,c时，中间用sep隔开。（即sep规定一种分割方式）
（4）format格式化：
s = "cf is too difficult {2} {0} {1}" .format ("choose","development","I")
print(s)
//输出：cf is too difficult I choose development‘{ }’中的数字代表位置，（记住从0开始就好！！！）
（5）字典：
s = "cf is too difficult I %(b)s %(a)s" % {'a':'development','b':'choose'}
print(s)大家有没有发现与上面的“占位符”的用法有点像。
2.字符串函数：
大小写：lower() , upper() , swapcase() 大小写互换, capitalize()首字母大写其他小写 , title() 每个单词首字母大写其他小写 ；
搜索与替换：find() , rfind() , index() , rindex() , count() , replace() , strip() , lstrip() , rstrip() , expandtabs()把串换成空格 ；
分割与组合：split() , splitllines() , join() ；
二.列表：
1.与列表有关常用函数：
list() , count() , append()入栈 , len() , extend() , insert() , pop() , remove() , index() , reverse() , sort() , sorted() , cmp() , set()不懂的百度！
2. 切片：
a = [1,2,3,4,5,6,7］
正向索引
a[0:4:1] 表示从0位开始去到第4位，步长为1,结果为[1,2,3,4]
反向索引
a[-1:-4:-1],取到[7,6,5] #反向索引的步长一定要加上，并且步长要写为负数
注意：不管是正向索引还是反向索引，索引后面的一个值，是不算在内的
3. 添加操作：
（1) + ：生成一个新的列表
a = [1,2,3]
b = [4,5,6]
a + b 输出为[1,2,3,4,5,6]
（2) extend ：接受参数并将该参数的每个元素都添加到原有的列表中，原地修改列表而不是新建列表。
a.extend(b)
a的输出为[1,2,3,4,5,6],对比操作前后的id(a),值是不变的
（3) append : （入栈）添加任意对象到列表的末端，参数为单个元素，这个元素可以是数字，也可以是list或者元组本身。
a = [1,2,3]
a.append(4)
a的输出为：[1,2,3,4]
a.append([3,4,5])
a的输出为：[1,2,3,4,[3,4,5]]
（4) insert: 插入任意对象到列表中，可以控制插入位置。
a.insert(1,"ab") 表示在下标为1处加上元素“ab”
a的输出结果是[1,"ab",2,3,4,[3,4,5]]
4. 修改：
修改列表本身只需要直接赋值操作就行。（覆盖！！！）
5. 删除操作：
（1) del ：我们通过索引删除指定位置的元素。（强调位置）
a = [1,2,3,4,5]
del a[0]
a输出为[2,3,4,5]
（2) remove：移除列表中指定值的第一个匹配值。如果没找到的话，会抛异常。（强调元素值）
a.remove(4)
a.remove(6) //这个会wa的 ! （括号里的东东不是下标哦）
（3) pop：返回最后一个元素，并从list中删除它。
a.pop()，输出为5，并删除5
也可指定元素索引值，弹出并删除指定元素，比如a.pop(1)，弹出并删除数字2。
三.元组：
说到元组，小编认为，元组应该是列表与集合的部分属性的结合体。（不知道说的对不对哈，望大佬们看后指点一番2333~~）
元组也是python内置一个容器类，元组中的数据一旦确定就不可更改，不能进行添加、删除、修改的操作。
（1）声明元组
tuple_1 = ( 3.14 , 'hello' , 'world' , 2 , 3 , 5 ,1 , 2 )
print(tuple_1)
or：
tuple_2 = 1,2,3,4,5,6,7,8 ( 声明元组可以省略括号，即tuple_1中去掉括号亦可)
print(type(tuple_2)) // 输出：<class 'tuple'>
（2）引用元组元素：
引用下标即可，与列表操作一样。就不展开说了哈2333~
（3）切片：
元组也支持切片操作，将一个元组切片之后，其返回值也为元组。
对上述tuple_1，若进行tuple_1[1:4] //输出：（''hello' , ' world ' , 2 ）。
（4）元组支持for循环遍历
方法一：
for x in range(0,len(tuple_1)):
a = tuple_1[x]
print(a)方法二：
for a in tuple_1:
print(a)
（5）元组的嵌套：
一个元组可以包含一个元组，（即某一个元组可以成为另一个元组的元素），我不细说，打cf的人应该都懂。
（6）列表和元组中间可以互相转换
list_1 = [1,2,3,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
tuple2 = tuple(list2) //(把列表转换为元组)
list2 = list(tuple2) //(把元组转换为列表)
（9）index(x,start,end)函数 查找某个元素在元组中的位置 （这个我也忘了）
index = tuple_2.index(3,0,3) 注意若要查找元素在元组中有多个，返回最前面的那个就好。
print(index)
（10）count(x) 函数统计某个元素在元组中出现的次数
元组.count(查找元素)
四.集合：
元素唯一，无序！！！（与C++的STL中的set不太一样）
在python中，set存放是用一种类似于数组最大位取模的方法，来减小内存。（所以无序）
1.创建集合：可以分为两种，（一种是可以改变的，另一种是一旦创建后就不能更改的）
（1）可变：set():
a = set("abc")
>>>{'a','b','c'}
（2）不可变的：frozenset()：
a = frozenset("abc")...
反正用add，或者remove操作，（2）会wa
2.
2. 添加操作： add，update
（1）add()
a.add("python")
输出为
set(['a', 'python', 'c', 'b']) #"python"做为一个整体来加入。
（2）update()
>>> b = set("hong")
>>> b
set(['h', 'g', 'o', 'n'])
>>> b.update("python")
>>> b
set(['g', 'h', 'o', 'n', 'p', 't', 'y']) #python分开来插入，如果重复自动忽略
注意：
update的参数也可以是list，如果使用list，那么集合中新加的元素还会保持原先list中的顺序。
比如c='hong'
b.update(list(c))
3. 删除 remove
与列表效果一样。
4.交集、并集、差集等运算（这个是copy别人的2333~~~）
- (set1 & set2) # 交集
- (set1 | set2) # 并集
- (set1 - set2) # 差集
- (set1 ^ set2) # 对称差集
# 集合可以去重
>>> set1 = {1, 2, 3, 3, 3, 2}
>>> print(set1)
{1, 2, 3}
# 获取集合长度
>>> print('Length =', len(set1))
Length = 3
# 创建数字1-9的集合
>>> set2 = set(range(1, 10))
>>> print(set2)
{1, 2, 3, 4, 5, 6, 7, 8, 9}
# 增加集合元素方法
>>> set1.add(4)
>>> set1.add(5)
>>> set2.update([11, 12])
>>> print(set1)
{1, 2, 3, 4, 5}
>>> print(set2)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
# 移除集合元素
>>> set2.discard(5)
>>> set2.remove(4)
>>> print(set2) # 如果不存在会引发KeyError
{1, 2, 3, 6, 7, 8, 9, 11}
# 将元组转换成集合
>>> set3 = set((1, 2, 3, 3, 2, 1))
>>> print(set3.pop())
1
>>> print(set3)
{2, 3}
# 集合的交集、并集、差集、对称差运算
set1={1, 2, 3, 4, 5}
set2={1, 2, 3, 6, 7, 8, 9, 11, 12}
>>> print(set1 & set2) # 交集
# print(set1.intersection(set2))
{1, 2, 3}
>>> print(set1 | set2) # 并集
# print(set1.union(set2))
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
>>> print(set1 - set2) # 差集
# print(set1.difference(set2))
{4, 5}
>>> print(set1 ^ set2) # 对称差集
# print(set1.symmetric_difference(set2))
{4, 5, 6, 7, 8, 9, 11, 12}
# 判断子集和超集
>>> print(set2 <= set1)
# print(set2.issubset(set1))
False
>>> print(set3 <= set1)
# print(set3.issubset(set1))
True
>>> print(set1 >= set2)
# print(set1.issuperset(set2))
False
>>> print(set1 >= set3)
# print(set1.issuperset(set3))
True五.字典：
字典与集合一样也是无序的，它不能通过偏移来存取，只能通过键来存取。（key-value）
格式：字典 = { key : value } key：类似我们现实的钥匙，而value则是锁。一个钥匙开一个锁（我们可以用key来表示value的值，but不能用value来引用表达出key的值）如下：
z = {'a': 1, 'b': 2}
print(z['a'])
//输出：1
z = {'a': 1, 'b': 2}
print(z[1])
//but，如果这样就会报出：KeyError: 1 的错误特点：
内部没有顺序，通过键来读取内容，可以嵌套，方便我们组织多种数据结构，并且可以原地修改里面的内容，属于可变类型。
组成字典的键必须是不可变的数据类型，比如，数字，字符串，元组等。but列表等可变对象不能作为键（这个很重要！）
测试如下：
（1）key 为数字
>>> z = {1:"22",2:"dd"}
>>> z
{1: '22', 2: 'dd'}
（2）key为字符串
>>> z = {"a":"222","b":111}
>>> z
{'a': '222', 'b': 111}
（3）key为元组，需要注意的是元组中的元素也必须是不可变类型。
eg：元组中的元素不能是列表！！！
>>> z = {(1,2,3):'ss',('b','c'):'222'}
>>> z
（4）元组中可以嵌套元组
{('b', 'c'): '222', (1, 2, 3): 'ss'}
>>> z = {(1,2,(1,2)): 1}
>>> z
{(1, 2, (1, 2)): 1}1.创建字典（两种）：
方法1：z = {'name':'lcx', 'age': 19}
方法2：z = dict(name='lcx',age=19)
name是key，'lilei'是value
注意：
（1） 方法一是用花括号，方法二是用小括号。
（2）方法一：key和value中的字符串必须加引号；
方法二：key的字符串可以不用加双引号，value的字符串必须加双引号。
（3） 方法一用 “ ： ”，方法二用 “ = ”。
2.添加内容 a [ 'xx' ] = 'xx'（value是数字就不用加引号）
3. 修改内容 a['xx'] = 'xx' （与增加类似）
找到字典中的 key ，进行赋值（可以理解为覆盖）
另一种方法为：update 参数是一个字典的类型，他会覆盖相同键的值
在z = {'name': 'lcx', 'age': 19, 'cf': 1200} 基础上进行操作。
z.update({'name':'TL','age':20})变为：{'name': 'TL', 'age': 20, 'cf': 1200} ，其中的name与age的value被改变了。
4. 删除 （三种）del,clear,pop：
（1）del z['key'] 删除某个元素
（2）clear()删除字典的全部元素
z.clear() 就好，字典被清空
（3）z.pop('key')
传入需要删除目标的key，就可删除。
eg ：（1），（3）测试
z = {'name':'lcx','age':19,'cf':1200}
del z['cf']
print(z)
//输出：{'name': 'lcx', 'age': 19}
z.pop('age')
print(z)
//输出：{'name': 'lcx'}5.in 和 has_key()：
z = {'name':'lcx','age':19,'cf':1200}
（1）in 操作：
>>> "tl" in z
False
>>> 'lcx' in z
True
（2） keys(): 返回的是列表，里面包含了字典的所有键
>>> z.keys()
输出：dict_keys(['name', 'age', 'cf'])
（3） values():返回的是列表，里面包含了字典的所有值
>>> z.values()
输出：dict_values(['lcx', 19, 1200])
（4）items()：生成一个字典的容器：------这个方法是字典转变为list的途径
>>>z.items()
dict_items([('name', 'lcx'), ('age', 19), ('cf', 1200)])
（5）get：从字典中获得一个值(get一个key，输出value)
>>>z.get('name')
输出：lcx。
