str list tuple dict

### str   -  list -  tuple - dict

------

### 1.str

```python 
python 自带的dir函数可以查看序列的放法
使用方法：
    print(dir(‘dsad‘))
1.index（find）：查找某一个字符的起始位置，若找不到，index报错，find返回假
    rfind 从右侧开始查找
2.split：根据某一个字符分割字符串，返回列表，字符切掉

3.replace: 将字符串的老的替换成新的
    
4.count：返回一个字符串中要寻找的字符的个数。

5.isdigit：判断字符串是否只有数字，返回值为True或者False

6.isalpha：判断字符串是否只有字母，返回值为True或者False

7.endswith：判断是否以某个值为结束，返回值为True或者False

8.startswith：判断是否以某个值为开始，返回值为True或者False

9.islower：判断是否只有小写，返回值为True或者False，出现除英文字符外的字符对返回值没有影响，但是若没有英文字符，返回值均为False

10.isupper：判断是否只有大写，返回值为True或者False

11.a.capitalize()：首字母大写

12.a.title()：单词首字母大写

13.upper：所有英文字符串转换为大写

14.lower：所有英文字符串转换为小写

15.strip：消除字符串前后的所有空格，中间的去不掉（lstrip只取消掉字符串左边的空格，rstrip只取消字符串右边的空格）
#-----------------------------------------------------------------------------
title()以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。
name = "ada lovelace" 
print(name.title())

first_name = "ada" 
last_name = "lovelace" 
? full_name = first_name + " " + last_name 
print(full_name)  --> ada lovelace


使用制表符或换行符来添加空白
print("Languages:\nPython\nC\nJavaScript")
Languages: 
Python 
C 
JavaScript

>>> print("Languages:\n\tPython\n\tC\n\tJavaScript") 
Languages: 
     Python 
     C 
     JavaScript

删除空白

```

### 2.list

```python
list：
1、创建列表
    只要把逗号分隔的不同的数据项使用方括号（[ ]）括起来即可 下标（角标，索引）从0开始，最后一个元素的下标可以写-1
    list=[‘1‘,‘2‘,‘3‘]
    list=[]

2、往表中插入元素
    list.append() 在list 末尾增加一个元素
    list.insert（n,‘4‘） 在指定位置添加元素，如果指定的下标不存在，那么就是在末尾添加
    list1.extend(list2) 合并两个list   list2中仍有元素

3、查看列表中的值
    print(list)    遍历列表
    等价于    for i in list:
                   print i
    print(list[n])  使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符
    print(list.count(xx)) 查看某个元素在这个列表里的个数，如果改元素不存在，那么返回0
    print(list.index(xx))找到这个元素的小标，如果有多个，返回第一个，如果找一个不存在的元素会报错

4、删除表中的值
    list.pop() 删最后一个元素
    list.pop(n)指定下标，删除指定的元素，如果删除一个不存在的元素会报错
    list.remove(xx) 删除list 里面的一个元素，有多个相同的元素，删除第一个 
    print(list.pop()) 有返回值
    print(list.remove()) 无返回值
    del  list[n] 删除指定下标对应的元素 
    del list 删除整个列表， list删除后无法访问

5、排序与反转    
    list.reverse()将列表反转
    list.sort()排序，默认升序
    list.sort(reverse=True) 降序排列

6、列表操作的函数
    1、len(list)：列表元素个数 
    2、max(list)：返回列表元素最大值 
    3、min(list)：返回列表元素最小值 
    4、list(seq)：将元组转换为列表
    5、enumerate 用法（打印元素对应的下标）
    同时取下标，元素

7、list 循环和切片
     1，循环
    for i in list:
           print i
    如果直接for 循环一个list 的时候，那么每次循环的值都是这个list 里面的元素
    2，切片（list 取值的一种方法）
    name[n:m]  切片是不包含后面那个元素的值（顾头不顾尾）
    name[:m] 如果切片前面一个值缺省的话，从开头开始取
    name[n:] 如果切片后面的值缺省的话，取到末尾
    name[:] 如果全部缺省，取全部
    name[n:m：s] s：步长  隔多少个元素取一次
    步长是正数，从左往右取
    步长是负数，从右往左取
```

### 3.tuple

```python
1、del
　　删除元组
    1 #del 删除元组
    2 a=(1,2,3)
    3 del a
    4 print(a)

2、len()
　　计算元组中，值的个数
    1 #len：计算元组元素的个数
    2 a=(1,2,1,2,1,2,1,1,1,1)
    3 print(len(a))
 
3、max()
　　返回元组中元素的最大值
　　注意：如果tuple中包含数字和字母时，不能使用max方法
    1 #max:返回元组中元素的最大值
    2 a=(1,2,3,4,1,8,1)
    3 print(max(a))
    4 b=(‘a‘,‘b‘,‘c‘)
    5 print(max(b))

4、min()
　　返回元组中元素的最小值
    1 #min:返回元组中元素的最小值
    2 a=(1,2,3,4,1,8,1)
    3 print(min(a))
    4 b=(‘a‘,‘b‘,‘c‘)
    5 print(min(b))
    5、tuple()

　　表示将列表转换为元组

1 #tuple:将列表序列转换为元组
2 a=[1,2,3,4,1,5,‘q‘,‘g‘]
3 print(tuple(a))
```

### 4.dict

```python
#1. clear方法清除字典中所有的项，这是一个原地操作，所以无返回值（或则说返回None）
d = {‘name‘:"tom"}
d.clear()
print(d)                                         #the result : {}

#2. fromkeys方法使用给定的键建立新的字典，每个键都对应一个默认的值None
print({}.fromkeys([‘name‘,‘age‘]))              #the result　：　{‘age‘: None, ‘name‘: None}

#3. get方法是个更宽松的访问字典项的方法，如果试图访问字典中不存在的项时不会报错仅会      返回：None
d = {‘Tom‘:8777,‘Jack‘:8888,‘Fly‘:6666}
print(d.get(‘Tom‘))                              #the result ：     8777
print(d.get(‘not_exist‘))                       #the result ：     None

#4. for循环字典的三种方法
d = {‘Tom‘:8777,‘Jack‘:8888,‘Fly‘:6666}
for k,v in d.items():
    print(k,v)
for k in d.values():
    print(k)
for k in d.keys():
    print(k)

#5. pop方法用于获得对应与给定键的值，然后将这个”键-值”对从字典中移除
d = {‘Tom‘:8777,‘Jack‘:8888,‘Fly‘:6666}
v = d.pop(‘Tom‘)
print(v)                    #8777


#6. setdefault方法在某种程度上类似于get方法，能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值
d = {‘Tom‘:8777,‘Jack‘:8888,‘Fly‘:6666}
d.setdefault(‘Tom‘)                           #the result ： 8777
print(d.setdefault(‘Test‘))                  #the result ： None
print(d)                                      #{‘Fly‘: 6666, ‘Jack‘: 8888, ‘Tom‘: 8777, ‘Test‘: None}

#7. update方法可以利用一个字典项更新另一个字典，提供的字典中的项会被添加到旧的字典中，如有相同的键则会被覆盖
d = {‘Tom‘:8777,‘Jack‘:8888,‘Fly‘:6666}
a = {‘Tom‘:110,‘Test‘:119}
d.update(a)
print(d)                                       #the result ：{‘Fly‘: 6666, ‘Test‘: 119, ‘Jack‘: 8888, ‘Tom‘: 110}

#8. 将两个列表组合成字典
keys = [‘a‘, ‘b‘]
values = [1, 2]
print(dict(zip(keys,values)))                                      # {‘a‘: 1, ‘b‘: 2}
```