标签：width 增加值 推荐 简单 返回 运算 2.0 就会 笔记
一.整形和浮点型
整形也就是整数类型(int)的，在python3中都是int类型，没有什么long类型的，比如说存年龄、工资、成绩等等这样的数据就可以用int类型，有正整数、负整数和0，浮点型的也就是小数类型(folat)的，带小数点的
1 name=‘你长得真漂亮‘ 2 age=‘88‘ 3 print(name) 4 print(age) >>>你长得真漂亮 >>>88
二.布尔类型
什么是布尔类型，布尔类型就是真和假，只有这两种，True和Fasle，非真即假，除了True和False还有0和1，非0即真,非空即真
1 t = True 2 f = False
三.字符串和字符串操作
上面说了存数字，那要是想存自己的名字呢，那用int类型的就不行了，不能一个人的名字叫数字吧，这样怎么办呢，就有另一种数据类型应运而生，就是字符串，它可以存任意类型的字符串，比如名字，一句话等等。
1 name=‘你长得真漂亮‘
字符串是可以通过下表来进行取值的，但是由于字符串是不可变变量，不能通过下标来修改它的值
username = ‘li‘ username[0]
字符串还有很多内置的方法，对字符串进行操作，常用的方法如下，下面注释带有是否的，返回的都是一个布尔值：
1 name = ‘my \t name is {name},age is {age}.‘ 2 print(name.capitalize())#大写 3 print(name.center(50,‘-‘))#50个-，把name放中间 4 print(name.endswith(‘u‘))#是否以u结尾
print(name.startswith(‘a‘):)#是否以a开头
5 print(name.expandtabs(30))#补\t的次数
6 print(name.find(‘n‘))#查找字符串的索引 7 print(name.format(name=‘niuniu‘,age=18)) 8 #这个是格式字符串，再第一节的博客里面已经写了 9 print(name.format_map({‘name‘:‘niuniu‘,‘age‘:19})) 10 #这个也是格式化字符串，后面跟的是一个字典，字典在后面也会写 11 print(‘abA123‘.isalnum())#是否包含数字和字母 12 print(‘abA‘.isalpha())#是否是英文字母 13 print(‘122‘.isdigit())#是否是数字 14 print(‘aa‘.isidentifier())#是否是一个合法的变量名 15 print(‘aa‘.islower())#是否是小写字母 16 print(‘AA‘.isupper())#是否是大写字母 17 print(‘Loadrunner Book‘.istitle())#是不是一个标题，判断首字母是否大写 18 print(‘+‘.join([‘hehe‘,‘haha‘,‘ee‘]))#拼接字符串 19 print(name.lower())#变成小写 20 print(name.upper())#变成大写 21 print(‘\nmysql \n‘.lstrip())#默认去掉左边的空格和换行 22 print(‘\nmysql \n‘.rstrip())#默认去掉右边的空格和换行 23 print(‘\nmysql \n‘.strip())#默认去掉两边边的空格和换行 24 p = str.maketrans(‘abcdefg‘,‘1234567‘)#前面的字符串和后面的字符串做映射 25 print(‘cc ae gg‘.translate(p))#输出按照上面maketrans做映射后的字符串
print(st.replace(‘mysql‘, ‘oracle‘)) # 替换字符串
下面是反解:
1 new_p = str.maketrans(‘1234567‘,‘abcdefg‘) 2 print(‘cc ae gg‘.translate(new_p)) 3 print(‘mysql is db.‘.replace(‘mysql‘,‘oracle‘,1))#替换字符串 4 print(‘mysql is is db‘.rfind(‘is‘))#返回最右边字符的下标 5 print(‘1+2+3+4‘.split(‘+‘))#切割字符串，返回一个list 6 print(‘1+2+3\n1+2+3+4‘.splitlines())#按照换行符分割 7 print(‘Abcdef‘.swapcase())#大小写反转
四.列表和列表操作
上面说了字符串和整形，那现在要是想存一个班级的人的名字，这个班有200个人，怎么存呢，用字符串的话，那就是names = ‘marry lily king .....‘这样，但是这样存是可以存，那要是想取到某个人的名字怎么取呢，不能再去里面看一遍吧，那累死人了，为了解决这个问题，又有一种新的数据类型应运而生，那就是列表，这也是我们在以后的开发过程中，最常用的数据类型之一，列表也叫数组，列表定义，使用[]即可；列表里面可以再套列表，一个里面套一个列表，叫二维数组；一个里面套一个列表，里面的列表再套一个列表，这个叫三维数组，套几层就是几维，定义格式如
list1 = [1,2,3,4] #一个普通的数组 list2 = [‘marry‘,‘lily‘,[50,‘monkey‘]] #二维数组 list3 = [‘name‘,‘sex‘,[‘lily‘,124,[‘aaaa‘,‘bbb‘]]] #三维数组
通过下标访问列表中的元素，下标从0开始计数，也就是说，比如说一个列表，有个5元素，那么它第一个元素下标就是0，第二个就是1，以此类推，字符串也有下标，和列表一样
对列表的操作，分以下几种增、删、改、查
增:
1 msg = ‘你好‘ 2 name = [‘andashu‘,‘cc‘,‘niuniu‘] 3 name.append(msg)#从最后面开始插入 4 name.insert(1,msg) #从指定位置插入，这个1代表下标 5 print(name)
删:
print(‘before ‘,names)
print(‘pop返回值:‘,names.pop())
print(‘remove 方法的返回值‘,names.remove(‘yinwenqiao‘))
del names[0]#使用del关键字删除指定元素
names.pop()#默认删除最后一个元素，删谁也把它的值返回了
names.pop(2)#删除指定位置的元素
names.clear()#清空列表
names.remove(‘yinwenqiao‘)
删除指定的值，要和pop方法区别开来，pop如果删除的话，传是下标，reomve传的是一个元素的值
查:
1 msg = ‘你好‘ 2 name = [‘andashu‘,‘cc‘,‘niuniu‘] 3 print(name[0])#获取第一个元素 4 print(name[-1])#-1代表最后一个元素
改:
1 msg = ‘你好‘ 2 name = [‘andashu‘,‘cc‘,‘niuniu‘] 3 name[1] = ‘baby‘ #修改指定位置的值,通过下标修改值
列表操作，一些内置的方法
1 print(names.count(‘hsdfsdf‘))#查找值在list里面的次数 2 print(‘names‘,names) 3 print(names.index(‘yinwenqiao‘))#返回查找元素的下标，如果有多个话返回第一个的，如果没有的话就会报错 4 print(names.index(‘yinwenqiao‘,3,4))#后面可以加上查找开始位置和结束位置 5 6 stus = [‘yangwb‘,‘yangwn‘,‘yanghj‘] 7 print(‘加起来的‘,stus+names)#两个列表合并 8 print(‘这个是extend：‘,stus.extend(names))#把另一个列表里面的每个值挨个添加到前面的列表中 9 print(‘这个是extend：‘,stus) 10 11 nums = [23,34,21,2,456,35,12324324] 12 nums.sort()#排序，默认是升序 13 print(‘sort：‘,nums) 14 print(nums.sort(reverse=True))#排序，指定reverse=True就是降序 15 print(‘sort降序：‘,nums) 16 print(nums.reverse()) 17 print(nums)
列表循环:
for name in names:
print(name)
切片，切片也就是另一种方式获取列表的值，它可以获取多个元素，可以理解为，从第几个元素开始，到第几个元素结束，获取他们之间的值，格式是name:[1:10]，比如说要获取name的第一个元素到第五个元素，就可以用name[0:6]，切片是不包含后面那个元素的值的，记住顾头不顾尾；前面的下标如果是0的话，可以省略不写，这样写，name[:6]，切片后面还有可以写一个参数，叫做步长，也就是隔多少个元素，取一次，默认可以不写，也就是隔一个取一次，切片操作也可以对字符串使用，和列表的用法一样，实例如下：
1 names = [‘andashu‘,‘cc‘,‘niuniu‘,‘amy‘,‘lily‘] 2 names[1:4] #取下标1至下标4之间值，包括1，不包括4 3 names[1:-1] #取下标1至-1的值，不包括-1 4 names[0:3] #取下标0至3的值，不包括3 5 names[2:]#取从第二个下标开始的后面所有元素 6 #下面是加上步长的 7 nums = [1,2,3,4,5,6,7,8,9,10] 8 nums[::2]#这个代表取所有的元素，然后每隔2个元素取一个 9 >>> 1 3 5 7 9 #输出的结果 10 nums[1:8:3]#代表取第二个元素开始，到第八个结束，隔3个取一次 11 >>>[2,5] #输出结果
五.元组
元组其实和列表一样，不一样的是，元组的值不能改变，一旦创建，就不能再改变了，比如说，要存数据库的连接信息，这个连接信息在程序运行中是不能被改变的，如果变了那数据库连不上了，就程序就完犊子了，这样的就可以使用元组了，元组呢，也提示别人，看到是元组的话，就说明这个值是不能被改变的，元组的定义方式是用()，小括号；元组只有两个方法，那就是count和index
mysql_coon = (‘192.168.1.109‘,‘root‘,‘123456‘,3306,‘my_db‘)#定义元组
六.字典
上面说了，整形、浮点型、字符串、列表和元组，下面说个新的数据类型，字典，字典也是我们开发过程中最常用的一种数据类型；想一个问题，现在要存整个北京市的所有人的信息，每个人有姓名、年龄、性别、家庭住址、学历等等，那要是用列表存的话，那就得定义N多个数组，然后存上每个人的信息，那累死人了。。。这时候又有一种新的数据类型出现了，那就是字典，dict，全称是dictionary，它具有极快的查找速度；字典是一种key-value的数据类型，比如说要存每个人的信息，那么每个人的编号就是key，value就是每个人的信息，这样的话，一个字典就能存所有人的信息了。字典的定义使用{}，大括号，每个值用“，”隔开，key和value使用“：”分隔。
举个列子，如果用列表存每个人的信息的话，需要用两个列表，一个存人名，一个存信息：
1 names = [‘marry‘,‘amy‘,‘lily‘] 2 infos = [[18,18612512981,‘北京‘],[20,18612512991,‘山东‘],[25,18612532981,‘河南‘]]
给一个名字，如果要查他的对应信息，那就要先从names里面找到它的位置，然后再从infos中找到它的信息，如果这个列表越长，那么它的查询速度越慢。
如果用字典实现的话，只需要一个名字和信息对应的一个表，这样就很快的根据名字找到它对应的信息，无论这个表有多大，查找速度都不会变慢
1 infos = {‘marry‘:[18,18612512981,‘北京‘],‘amy‘:[20,18612512991,‘山东‘],‘lily‘:[25,18612532981,‘河南‘]} 2 infos[‘marry‘] #取marry的信息
为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。
第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢，这种就是字典的实现方式。
字典的特性：
字典是无序的，因为它没有下标，用key来当索引，所以是无序的
字典的key必须是唯一的，因为它是通过key来进行索引的，所以key不能重复，天生就去重
字典的增删查改:
增:
1 infos = {‘marry‘:[18,18612512981,‘北京‘],‘amy‘:[20,18612512991,‘山东‘],‘lily‘:[25,18612532981,‘河南‘]} 2 infos[‘andy‘]=[22,18712512981,‘河北‘]#增加
删:
1 infos = {‘marry‘:[18,18612512981,‘北京‘],‘amy‘:[20,18612512991,‘山东‘],‘lily‘:[25,18612532981,‘河南‘]} 2 infos.pop(‘marry‘)#标准的删除方法 3 del infos[‘marry‘]#使用del方法删除 4 info.popitem() #随机删除一个值
查:
1 infos = {‘marry‘:[18,18612512981,‘北京‘],‘amy‘:[20,18612512991,‘山东‘],‘lily‘:[25,18612532981,‘河南‘]} 2 infos.get(‘maryy‘)#获取marry的信息，这种方式如果key不存在的话，会返回None 3 infos[‘marry‘]#获取marry的信息，这种方式如果key不存在的话，会报错 4 ‘marry‘ in infos #判断marry是否在这个字典中，返回True或者False
改:
1 infos = {‘marry‘:[18,18612512981,‘北京‘],‘amy‘:[20,18612512991,‘山东‘],‘lily‘:[25,18612532981,‘河南‘]} 2 infos[‘marry‘:[38,18612512981,‘北京‘]]
字符串内置方法:
1 dic = {‘stu1‘:‘cc‘,‘stu2‘:‘andashu‘,‘stu3‘:‘niuniu‘} 2 print(dic.values())#打印所有value 3 print(dic.keys())#打印所有的key 4 print(dic.setdefault(‘stu1‘,‘fengluo‘)) 5 #如果这个key存在的话，那就不动它，不存在的话，添加一个 6 dic2 = {‘stu1‘:‘sriba‘,‘stu10‘:‘baidu‘} 7 dic.update(dic2)#更新字典值，如果key存在的话，就更新，不存在的话就添加 8 print(dic.items())#字典转换成一个list
字典的循环:
1 dic = {‘stu1‘:‘cc‘,‘stu2‘:‘andashu‘,‘stu3‘:‘niuniu‘} 2 for k in dic: 3 print(k,dic[k])#打印key和value的值，推荐使用这种方式，速度快 4 for k,v in dic.items(): 5 print(k,v)#打印key和value的值，这种方式不推荐，因为会把字典转换成列表，效率不高
七.集合
集合也是一种数据类型，一个类似列表东西，它的特点是无序的，不重复的，也就是说集合中是没有重复的数据.
集合的作用：
1、它可以把一个列表中重复的数据去掉，而不需要你再写判断.集合天生去重.
2、可以做关系测试，比如说有两个班，一个A班，一个是B班的，想找出来既即是A班又是B班的同学，就可以用集合
定义集合
1 list = [2,3,1,2,3,4] 2 s_list = set(list)#这样就定义了一个集合 3 set1 = set([1,3,4,5,6])#这种方式和上面的都是把list转换成一个集合 4 set2={‘hehe‘,‘hehe1‘,‘hehe3‘}#这种方式是直接定义一个集合
集合操作
1 list1 = {1, 2, 3, 4, 5, 6, 9} 2 list2 = {2, 3, 4, 6, 1} 3 list3 = {1, 2, 3} 4 print(list1.intersection(list2)) 5 # 取交集，也就是取list1和list2中都有的 6 print(list1 & list2)# 取交集 7 print(list1.union(list2)) # 取并集，也就是把list1和list2合并了，然后去除重复的 8 print(list1 | list2)# 取并集 9 print(list1.difference(list2)) #取差集 在list中存在，在list2中没有的 10 print(list1 - list2) 11 print(list3.issubset(list1))#判断list3是不是list1的子集 12 print(list1.issuperset(list3))#判断list1是不是list3的父集 13 print(list1.isdisjoint(list3))#判断list1和list3是否有交集 14 print(list1.symmetric_difference(list2)) 15 # #对称差集，输出两个列表中都没有的值，也就是把两个集合中相同的去掉 16 # print(list1 ^ list2) 17 list1.add(888)#添加元素 18 list1.update([777,666,666]) 19 list1.remove(777)#删除元素，如果元素不存在会报错 20 list1.pop()#删除一个随机的元素，并返回删除的元素 21 list1.discard(‘dddd‘)#如果删除的元素存在，删除，不存在不做处理
八、三元运算符
三元运算符就是在赋值变量的时候，可以直接给它加上判断，然后赋值
1 res = 值1 if 条件 else 值2 2 a = 5 3 b = 4 4 c = a if a>b else b #如果a大于b的话，c=a，否则c = b ，如果不用三元运算符的话，就得下面这么写 5 if a>b: 6 c = a 7 else: 8 c = b
当然三元运算符也可以用在列表和字典中，这么写的话，就比较简单了，不过如果搞不明白三元运算符的话，还是不用为好
1 nums = [1,2,3,4,5,6,7,8,9,10] 2 odd_num = [num for num in nums if num%2!=0]#循环nums，如果nums里面的值，不能被2整除的话，就写到odd_num这个list中，也就是算奇数，等于下面这么写 3 odd_num = [] 4 for num in nums: 5 if num % 2 !=0: 6 odd_num.append(num)
九.数据运算符
算数运算符
| 操作符 | 描述 | 例子 |
| + | 加法 - 对操作符的两侧增加值 | a + b = 30 |
| - | 减法 - 减去从左侧操作数右侧操作数 | a - b = -10 |
| * | 乘法 - 相乘的运算符两侧的值 | a * b = 200 |
| / | 除 - 由右侧操作数除以左侧操作数 | b / a = 2 |
| % | 模 - 由右侧操作数和余返回除以左侧操作数 | b % a = 0 |
| ** | 指数- 执行对操作指数（幂）的计算 | a**b = 10 的幂 20 |
| // | 地板除 - 操作数的除法，其中结果是将小数点后的位数被除去的商 | 9//2 = 4 而 9.0//2.0 = 4.0 |
比较运算符
| 运算符 | 描述 | 实例 |
| == | 检查两个操作数的值是否相等，如果是则条件变为真 | (a == b) 为false |
| != | 检查两个操作数的值是否相等，如果值不相等，则条件变为真 | a != b) 为 true. |
| > | 检查左操作数的值是否大于右操作数的值，如果是，则条件成立 | (a > b) 不为 true. |
| < | 检查左操作数的值是否小于右操作数的值，如果是，则条件成立 | (a < b) 为 true. |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立 | (a >= b) 不为 true. |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立 | (a <= b) 为 true. |
Python赋值运算符
| 运算符 | 描述 | 示例 |
| = | 简单的赋值运算符，赋值从右侧操作数左侧操作数 | c = a + b将指定的值 a + b 到 c |
| += | 加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数 | c += a 相当于 c = c + a |
| -= | 减AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数 | c -= a 相当于 c = c - a |
| *= | 乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数 | c *= a 相当于 c = c * a |
| /= | 除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数 | c /= a 相当于c = c / a |
| %= | 模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数 | c %= a 相当于 c = c % a |
| **= | 指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数 | c **= a 相当于 c = c ** a |
| //= | 地板除，并分配一个值，执行地板除对操作和赋值给左操作数 | c //= a 相当于 c = c // a |
逻辑运算符
| 运算符 | 描述 | 示例 |
| and | 所谓逻辑与运算符。如果两个操作数都是真的，那么则条件成立。 | (a and b) 为 true. |
| or | 所谓逻辑OR运算符。如果有两个操作数都是非零然后再条件变为真。 | (a or b) 为 true. |
| not | 所谓逻辑非运算符。用于反转操作数的逻辑状态。如果一个条件为真，则逻辑非运算符将返回false。 | not(a and b) 为 false. |
身份运算符
| 运算符 | 描述 | 示例 |
| is | is判断两个标识符是否引用自一个对象 | x is y,如果id(x)等于id(y) ，返回True |
| is not | is not判断两个标识符是否引用不同的对象 | x is not y,如果id(x)不等于id(y)，返回True |
标签：width 增加值 推荐 简单 返回 运算 2.0 就会 笔记
原文地址：http://www.cnblogs.com/panpan0301/p/7277701.html
