Python语法day2-常用数据类型及操作
数值
a，整型（int）：2进制（0b + 二进制串），8进制（0/0o + 八进制串），10进制，16进制（0x + 16进制串）；
b，浮点型（float）：小数，也可以用科学计数法表示；
c，复数（complex）：由实部虚部构成complex(a,b)就表示a+bj，这里的ab都是浮点数；
Python 3中的整型可以自动调节大小，当做long类型来使用。
常用内建函数(直接可以用)：
abs(num),max(a,b,…),min(a,b…),round(num[,n]),pow(x,y)
常用模块函数(需导入相应的包才能使用):
ceil(num),floor(num),sqrt(num),log(x,base)
随机函数（import random包）:
randome(): 返回一个[0,1)内的随机小数；
choice(seq): 在 seq序列中随便选一个数字返回；
uniform(x,y): 返回[x,y]范围内一个随机小数；
randomint(x,y): 返回[x,y]范围内一个随机整数；
randrange(start, stop = None, step = 1): 返回[x,y)范围内一个随机整数（间隔为step）；
三角函数（import math包）：
sin(x), cos(x),tan(x),asin(x),acos(x),atan(x);
以上函数中参数X为弧度，比如30度，那么弧度为30/180 * pi应注意转换；
degress(x): 传入弧度，返回角度；
radians(x): 传入角度，返回弧度；
布尔
真True, 假False
字符串
拼接字符串：
1, str3 = “str1”+ “str2”,str3 = “str1str2”;
2, str1 = “str”*3, str1 = “strstrstr”;
切片字符串：
name = “123456”
1.利用下标切割单个字符：name[0] = “1”;
2.利用下表切割多个字符：name[0:5] = “12345”,返回[0,5)范围内的字符；
3.反转字符串：name[::-1] = “654321”,步长为负一表示每次退一步；
常用字符串函数：
1.内建函数：len(str),返回字符串str的长度;
2.模块函数：
find(sub， start = 0，end = len(str)), rfind(sub， start = 0，end = len(str))：
在目标字符串中从下标0到下标len(str)的范围内找sub字符串，如果找到，返回sub字符串在目标字符串中的第一次出现的下标，如果找不到，返回-1；find函数从左至右查找，rfind函数从右至左查找；
index(), rindex()：与find功能相同，但index函数如果找不到会报错，而不是返回-1；
replace(old, new,[count]):用新的字符串new替换原始字符串中的old片段，count为替换次数，默认为替换全部；函数返回替换后的新字符串；
capitalize():将字符串的首字母转为大写；
title():将字符串中的每个单词的首字母变为大写；
lower()/upper():将字符串的每个字符变为小写/大写；
ljust(width, fillchar)/rjust(width, fillchar)/center(width, fillchar)如果源字符串的长度小于width，那么用指定字符在右边/左边/两边填充至指定长度；
lstrip(char)/rstrip(char):移除字符串左/右侧的指定字符（默认为空白字符）；
split(seq, maxsplit):将一个大的字符串按照seq分隔成为几个较小的字符串,maxsplit表示最大分隔次数，默认为全部分隔次数；
partition(seq)，rpartition(seq):从左至右/从右至左按照seq将字符串分隔为三个部分，如果没有找到，后面两个分隔后的字符串为空；
splitlines(keepends):按照换行符分隔字符串，参数为bool类型表示是否在分隔后的子串中保留换行符，分隔后的子串作为列表元素被返回；
指定字符.join(iterable):将可迭代对象使用指定的字符串进行拼接，成为一个新的字符串；
isalpha()/isdigit()/isalnum()/isspace:字符串中是否都是字母/数字/数字或者字母/空格；
startwith(chars，start， end)/endwith(chars，start， end):是否以指定字符串开始/结束；
列表
概念： 有序的可变的元素集合
定义： 用中括号表示
1.num = [item1,item2,item3,…],当然也可以嵌套定义
2.生成列表：nums = range(99)；生成了[0-98]的列表
3.生成列表：nums = range(start，end，step)；生成了[start, end-1]的列表，元素间隔为step;
4.列表推导式（从一个列表推导另一个列表）：
1 1 映射推导：result = [num+1 for num in nums]:给num列表的每个元素平方，然后构成新的元素列表result；
过滤推导：result = [num+1 for num in nums if num % 2 != 0]:给num列表的奇数元素平方，构成新的元素列表result；
列表的常用操作：
1.增：append(object),将object添加到列表尾；insert(index, object)：在下标index处添加一个object，剩余元素向后移动；extend(可迭代对象):将可迭代的列表追加在当前列表之后，形成新列表；加法运算符：拼接两个列表；
2.删：clear():将列表清空；del 列表名：彻底删除整个列表，等于从来没有被定义过；del 列表名[下标]：删除指定位置的元素；列表名.pop():返回并删除列表最后一个元素；列表名.remove(object):移除列表中第一个object；
3.改：列表名[下标] = 修改后的值；
4.查：下标 = 列表名.index(object，start， end)；获取多个元素：count(start, end,step);
列表的判定操作：
1.判定一个元素在一个列表中：object in 列表名，返回类型为bool类型；
2.判定一个元素不在一个列表中：object not in 列表名，返回类型为bool类型；
3.内建比较函数cmp():从左至右比较两个元素，左＞右，返回1，左=右，返回0，左＜右，返回-1；Python 3 不支持cmp()；
4.内建比较函数cmp():从左至右比较两个元素，左＞右，返回1，左=右，返回0，左＜右，返回-1；Python 3 不支持cmp()；
列表的排序操作：
sorted(目标排序对象，排序关键字，升序（降序）)；返回一个排好序的对象；
排序对象.sort(排序关键字，升序（降序）)；返回排好序的当前列表；
列表的乱序操作：
导入random包，使用random.shuffle(乱序对象)；
列表的反转操作：
目标列表.reverse(),这个函数会改变列表本身的元素顺序；
与c语言数组的差别：可以放不同的元素类型;
元组
概念：有序的不可变的元素集合
定义：用小括号表示
1.单个元素元组定义：（元素，）
2.多个元素元组定义：（元素1，元素2，元素3，…）
3.将列表转为元组：tuple(列表名)，函数返回转换成功的元组；
4.元组的嵌套： （元素1，元素2，元组1，元组2，…）
元组的常用操作：
由于不可修改，所以没有增删改等操作，只能查询；
查询单个元素：元组名[index]; 返回index处的元组元素；
查询多个元素：元组名[start, end, step];返回范围内间隔为step的元素；
元组的获取操作：
元组名.count（object）：返回指定对象的个数；
元组名.index（item）：返回指定对象的位置下标；
len（元组名）：返回指定元组中的元素个数；
max（元组名）：返回指定元组中的最大元素；
min（元组名）：返回指定元组中的最小元素；
元组的判定操作：
元素 in 元组：元素是否在元组内；
元素 not in 元组：元素是否不在元组内；
元组的比较操作：
在Python 2中使用cmp()函数；
备注，如果cmp()函数中参数类型不同，则返回类型名比对结果（比对类型名还真是一个骚操作）；
在Python 3中使用>,<,=来比较；
元组的拼接操作：
乘法：（1，2，3）*3， 新元组就为(1,2,3,1,2,3,1,2,3);
加法：(1,2,3)+(4,5,6),新元组就为（1,2,3,4,5,6），加法要求数据类型相同；
元组的拆包操作：
一个元组相当于一个麻袋，拆分元组就是拆包；
a,b = (1,2), a,b 就是元组（1，2）的拆包结果；
字典
概念：无序的可变的键值对集合
定义：大括号表示
dictionary = ｛“name”:“mingzi”, “age”:“nianling”,…｝
d = dict.formkeys(“abc”, 666),定义结束后，d = {‘a’:666, ‘b’:666, ‘d’:666}
字典的常用操作：
增：字典名[key] = value,如果字典中没有key这个键值对存在，则为增加操作；
删：
1，dic.pop(key[,default]):删除指定key的键值对并返回，如果可以不存在则会报错；
2，dic.popitem():删除升序排序后的第一个（最小）键值对，并以元组的形式返回该键值对,如果字典为空则报错；
3，dic.clear()：删除字典所有内容；
4，del dic:删除内容，删除字典，相当于没有定义过；
改：
1，字典名[key] = value,如果字典中key这个键值对存在，则为修改操作；
2，oldDic.update(newDic):用新字典批量修改旧字典，旧字典没有的键值对进行添加；
查：
1，dic[key]: 获取单个值，如果不存在会报错；
2，dic.get(key[,default]):若不存在，返回默认值，但不会添加也不会报错；
3，dic.setdefault(key[, default])：若不存在，返回默认值，并为字典添加键值对，如果没有默认值，用None赋值；
4，dic.values():获取所有的值；
5，dic.keys():获取所有的键；
6，dic.items():获取所有的键值对；
7，遍历：先遍历所有的key,再根据key遍历所有的值；直接遍历所有的键值对；
集合
概念：无序的，不可随机访问，不可重复元素的集合，可对其进行逻辑运算；
定义：
可变集合：set
1，s = ｛1，2，3｝
2，s = set(可迭代对象)：用可迭代对象中的每一个元素给集合赋值；
不可变集合：frozenset
fs = frozensst(可迭代对象)
常用操作：
不可变集合只能查询：利用forin语句遍历，或者通过迭代器访问；
可变集合：
1，增：集合名.add（新增元素）；
2，删：
集合名.remove(指定元素)：删除指定元素，若不存在，报错；
集合名.discard(制定元素)：删除指定元素，若不存在，什么也不做；
集合名.pop()：随机删除集合中的某个元素，并返回，如果集合为空则返回一个错误；
集合名.clear()：清空集合中所有的元素，但不删除集合本身；
del 集合名：清除集合内容以及集合本身；
3，改：不能修改
4，查：
与不可变集合遍历方式相同；
5，交集：
集合1.intersection(集合2)：返回两个集合的交集；
集合1&集合2：返回两个集合的交集；
6，并集：
集合1.union(集合2)：返回两个集合的并集；
集合1 | 集合2：返回两个集合的并集；
7，差集：
集合1.difference(集合2)：返回两个集合的差集；
集合1 - 集合2：返回两个集合的差集；
8，判定：
集合1.isdisjoint(集合2)：两个集合是否不相交；
集合1.issuperset(集合2)：集合1是否包含集合2；
集合1.issubset(集合2)：集合1是否包含于集合2；
时间日历
time 模块：
1.time.time() 当前时间戳获取，获取1970年到现在的秒数；
2.time.localtime() 当前时间元组的获取；
3.time.ctime() 将第一个函数获取的秒数转化为，星期几，月份，日数，时分秒，年数的格式；
4.time.asctime() 将第二个函数获取的时间元组转化为，星期几，月份，日数，时分秒，年数的格式；
5.time.strftime("%y-%m-%d %H:%M:%S", 时间元组)：将时间元组转化为自定义格式；这一条中时间格式比较重要，下面是常用时间格式表示：两位年%y,四位年%Y，%m 月份， %d天数，%H 24小时的小时数，%I 12小时的小时数，%M 分钟数， %S 秒数 ， %a本地简化星期名称， %A本地完整星期名称，%h 英文简写的月份；
6.time.strptime(“年月日对应的字符串”，接收的格式应与字符串格式保持一致)：将字符串转化为时间格式，如下图所示；
7.time.mktime(时间元组)：将时间元组转化为时间戳；
8.time.clock()：获取当前CPU时间，可以用来计算程序耗时；
9.time.sleep(秒数)：延迟指定秒数再执行下一条语句；
calendar 模块：
import calendar
calendar.month(year, month):获取当月日历文本；
#####datetime 模块：
import datetime
1.获取当天时间：datetime.datetime.now() 或者 datetime.datetime.today();
2.计算N时间之后的时间：先获取当前时间，然后利用datetime.timedelta(要增加的项目=增加的数目)，然后用当前时间加上计算好的时间增量即可；
3.获取两个日期之间的时间差：先构造两个时间对象datetime.datetime(年，月，日，时，分，秒)，两个时间对象相减即可；
