元组到字典-阿里云天池

今天开始学习元组，字符串和字典
元组
元组是不可变类型的数据，它是一种有序的数列
元组是不可变类型的数据，因此像append() insert()等在列表中可以使用的方法，在元组中是不可以使用

# 元组是不可变类型的数据
t1 = (10,20,30,40)
t2 = (10,)
print(t1,t2)

还有一个需要的提醒的是，元组哪怕只有一个数字，在数字的末尾也需要加逗号（，）
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。

元组的内置函数：
1.比较两个元组元素：cmp(tuple1,tuple2)相等的话返回0，不相等返回1；
2.计算元组的长度：len(tuple
3.返回元组中的最大值最小值：max(tuple),min(tuple)；
4.将列表转换成元组：Tuple = tuple(list)。

字符串
字符串基本操作
切片

# str[beg:end]
# （下标从 0 开始）从下标为beg开始算起，切取到下标为 end-1 的元素，切取的区间为 [beg, end)
str = ' python str '
print (str[3:6])    # tho
# str[beg:end:step]
# 取 [beg, end) 之间的元素，每隔 step 个取一个
print(str[2:7:2])  # yhn

原始字符串

# 在字符串前加 r/R
# 所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符
print(r'\n')   # \n

字符串重复

# str * n, n * str
# n 为一个 int 数字
str = "hi"
print (str*2)   # hihi
print (2*str)   # hihi

in

str = ' python'
print('p' in str)    # True
print('py' in str)   # True
print('py' not in str) # False

字符串常用函数
去空格

str = ' python str '
print(str)
# 去首尾空格
print(str.strip())
# 去左侧空格
print(str.lstrip())
# 去右侧空格
print(str.rstrip())

分隔字符串

str = ' 1 , 2 , 3 , 4 , 5 , '
# 默认使用空格分隔
print(str.split())   # ['1', ',', '2', ',', '3', ',', '4', ',', '5', ',']
# 指定使用空格进行分隔，首尾如果有空格，则会出现在结果中
print(str.split(' ')) # ['', '1', ',', '2', ',', '3', ',', '4', ',', '5', ',', '']
# 指定其他字符串进行分隔
print(str.split(',')) # [' 1 ', ' 2 ', ' 3 ', ' 4 ', ' 5 ', ' ']
print(str.split('3 ,')) # [' 1 , 2 , ', ' 4 , 5 , ']
str = 'mississippi'
print(str.rstrip('ip'))
# 取行, python 中把 "\r"，"\n"，"\r\n"，作为行分隔符
str = 'ab c\n\nde fg\rkl\r\n'
print(str.splitlines())      # ['ab c', '', 'de fg', 'kl']
print(str.splitlines(True))  # ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

拼接字符串

# str.join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
str = '-'
seq = ("a", "b", "c"); # 字符串序列
print (str.join(seq))  # 'a-b-c'

统计字符串里某个字符出现的次数

# str.count(sub, start= 0,end=len(string))
str = "thing example....wow!!!"
print(str.count('i', 0, 5))  # 1
print(str.count('e'))  # 2

检测字符串中是否包含子字符串

# str.find(str, beg=0, end=len(string))
# 如果包含子字符串返回开始的索引值，否则返回-1。
str1 = "this is string example....wow!!!"
str2 = "exam"
print (str1.find(str2))      # 15
print (str1.find(str2, 10))  # 15
print (str1.find(str2, 40))  # -1
# str.index(str, beg=0, end=len(string))
# 如果包含子字符串返回开始的索引值，否则抛出异常。
print(str1.index(str2))     # 15
print (str1.index(str2, 10))# 15
print (str1.index(str2, 40))
# Traceback (most recent call last):
#   File "test.py", line 8, in
#   print str1.index(str2, 40);
#   ValueError: substring not found
# shell returned 1

# str.rfind(str, beg=0, end=len(string))
# str.rindex(str, beg=0, end=len(string))

判断字符串是否以指定前缀、后缀结尾

# str.startswith(str, beg=0,end=len(string))
# 检查字符串以指定子字符串开头，如果是则返回 True，否则返回 False
str = "this is string example....wow!!!"
print(str.startswith( 'this' ));       # True
print(str.startswith( 'is', 2, 4 ))    # True
print(str.startswith( 'this', 2, 4 ))  # False

# str.endswith(suffix[, start[, end]])
# 以指定后缀结尾返回True，否则返回False
suffix = "wow!!!"
print(str.endswith(suffix));         # True
print(str.endswith(suffix,20));      # True
suffix = "is";
print(str.endswith(suffix, 2, 4));   # True
print(str.endswith(suffix, 2, 6));   # False

字典
字典（Dict）
定义 Dictionary 使用一对大(花)括号” { } ”。
字典(Dictionary) 是 Python 的内置数据类型之一，它定义了键和值之间一对一的关系,但它们是以无序的方式储存的。字典中的“值”通过键来引用。

与列表区别：字典是无序的，在字典中通过键来访问成员。
字典是可变的，可以包含任何其他类型

声明:
M={k1:v1,k2:v2}
访问 M[k1]将得到v1

常用字典操作：
dic.clear()清空字典
dic.keys()获得键的列表
dic.values()获得值的列表
dic.copy()复制字典
dic.pop(k)删除键k
dic.get(k)获得键k的值
dic.update()更新成员，若成员不存在，相当于加入
dic.items()获得由键和值组成的列表

get()语法：
dict.get(key, default=None)
参数
key – 字典中要查找的键。
default – 如果指定键的值不存在时，返回该默认值值。
返回值
返回指定键的值，如果值不在字典中返回默认值None。

#定义一个集合
set1 = {1, 2, 3, 4, 5}
# 或者使用 set 函数
list1 = [6, 7, 7, 8, 8, 9]
set2 = set(list1)
set2.add(10) # 添加新元素
print set2 # set([8, 9, 6, 7]) 去掉重复内容,而且是无序的
set3 = frozenset(list1)    #固定集合
set3.add(10) # 固定集合不能添加元素
#方法（所有的集合方法）：
s.issubset(t) #如果s是t的子集,返回True，否则返回False
s.issuperset(t) #如果s是t的超集,返回True，否则返回False
s.union(t) #返回一个新集合, 该集合是s和t的并集
s.intersection(t) #返回一个新集合, 该集合是s和t的交集
s.difference(t) #返回一个新集合, 该集合是s的成员, 但不是t的成员, 即返回s不同于t的元素
s.symmetric_defference(t) #返回所有s和t独有的(非共同拥有)元素集合
s.copy() #返回一个s的浅拷贝, 效率比工厂要好
#方法（仅适用于可变集合）:以下方法参数必须是可哈希的
s.update(t) #用t中的元素 修改s，即s现在包含s或t的成员
s.intersection_update(t) #s中的成员是共同属于s和t的元素
s.difference_update(t) #s中的成员是属于s但不包含在t中的元素
s.symmetric_difference_update(t) #s中的成员更新为那些包含在s或t中，但不是s和t共有的元素
s.add(obj) #在集合s中添加对象obj
s.remove(obj) #从集合s中删除对象obj，如果obj不是集合s中的元素（obj not in s）,将引发keyError错误
s.discard(obj) #如果obj是集合s中的元素，从集合s中删除对象obj
s.pop() #删除集合s中得任意一个对象，并返回它
s.clear() #删除集合s中的所有元素
## 集合有并集，交集，求差操作
## 并集：intersection() 方法返回一个新集合，包含在两个集合中同时出现的所有元素。
## 交集：union() 方法返回一个新集合，包含在两个 集合中出现的元素。
## 差集：difference() 方法返回的新集合中，包含所有在 集合A出现但未在集合B中的元素。
## symmetric_difference() 方法返回一个新集合，包含所有只在其中一个集合中出现的元素。
# 删除元素
set2.discard(6) # 当元素不存在时,不会引发异常
set2.remove(6) # 与discard的区别在于，如果没有要删除的元素，remove会引发一个异常
set2.pop() # 因为set是无序的，所以pop会随机的从set中删除一个元素