python-笔记（二）数据类型

一、数据类型是什么鬼？
计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，
还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。

二、整形和浮点型

整形也就是整数类型(int)的，在python3中都是int类型，没有什么long类型的，比如说存年龄、工资、成绩等等这样的数据就可以用int类型，有正整数、负整数和0，浮点型的也就是小数类型(folat)的，带小数点的

    age = 18
    b = -50
    c = 5.222

浮点型转成整形，python会采取截断处理
字符串可以通过下标取值，不能通过下表改变值
len()取变量长度
a=5.99
b=int(a)
b=5

字符转成整数：
>>> a='520'
>>> b=int(a)
>>> b
520
>>> a='ddd' #如果本身不是数字强转数字就会报错
>>> b=int(a)
Traceback (most recent call last):
File "<pyshell#10>", line 1, in <module>
b=int(a)
ValueError: invalid literal for int() with base 10: 'ddd'

input默认都是string类型的如果和int类型比较就要强制转换，
或者用之前判断一下
不同类型不可以直接比较除了 浮点类型和int类型

三、布尔类型
type:内置函数，可以查看当前变量是哪一种数据类型
如 :a='520'
>>> type(a)
<class 'str'>
isinstance() 也可以判断变量的数据类型，会返回一个 布尔类型的值
例如：
>>> a='小甲鱼'
>>> isinstance(a,str)

True
>>> isinstance(320,str)
False
>>> 
s是当前的字符串
例如：

import random
secret = random.randint(1,10)
print('........我爱鱼C工作室...........')
temp = input("不妨猜一下小甲鱼心里想的是那个数字: ")
#加入输入错误类型是给出提示，请重新输入

while type(temp) != type(1) and not temp.isdigit():
    print("抱歉，输入不合法")
    temp = input("请输入一个整数：")
    guess = int(temp)
while guess !=secret:
    temp = input("哎呀，请重新输入： ")
    guess = int(temp)
    if guess == secret:
        print("我草，你是小甲鱼心里的蛔虫吗？")
        print("哼，猜对了也没有奖励！")
    else:
        if guess > secret:
            print("哥，大了。。大了")
        else:
            print("嘿嘿，小了小了")
print("游戏结束，不玩了")

　　

四、字符串和字符串的操作

所有的字符串方法都不会修改原来的 字符串的值，都会产生一个新的字符串

切片处理： 后面可以跟步长
>>> str1 = 'I LOVE fishC'
>>> str1[:6]
'I LOVE
如果【】里最前面和最后的数字都不写代表全部
str1[:]
str[::-1]倒叙取全部（当切片的步长是负数时是从末尾开始取值）
后面可以加步长
str[0:3:2]   每隔2个取一次

从字符串获取：用索引
>>> str1[:6]
'I LOVE'
>>> str1[5]
'E'（）

插入字符
>>> str1[:6]+"插入的字符串"+str1[6:]
'I LOVE插入的字符串 fishC'
>>> str1
'I LOVE fishC'
>>> str1 = str1[:6]+"插入的字符串"+str1[6:]
>>> str1
'I LOVE插入的字符串 fishC'

capitalize  把字符串的第一个字符改为大写
>>> str2 = 'xiaoxie'
>>> str2.capitalize()
'Xiaoxie'

casefold  把整个字符串字符改为小写
>>> str2 = 'DDDDsssss'
>>> str2.casefold()
'ddddsssss'
>>> str2
'DDDDsssss'

center   字符串居中，并使用空格填充至长度width的新字符串
>>> str2.center(40)
'               DDDDsssss                '

count（sub,[start],[end] ） 统计sub在start和end之间出现的次数
>>> str2
'DDDDsssss'
>>> str2.count("DD")
2
>>>

 endwith(sub,[start],[end]) :检查字符串是否以sub字符串结束，如果是返回
True，如果不是返回False

>>> str2.endswith("55")
False
>>> str2.endswith("ss")
True

find（sub,[start],[end]）  sub 是否包含在字符串中，如果有则返回第一个字符的索引值，如果没有返回-1
rfind从右边找
>>> str3.find("Fis")
7
>>> str3.find("dd")
-1

index（sub,[start],[end]）  跟 find一样，不过如果sub不在string中返回异常
rindex   从右边找
isalnum()  如果字符串是否有字符和数字则返回True，否则则返回False
isalpha() 如果字符串至少有一个字符，并且所有字符都是字母则返回True，否则返回False
isdecimal()如果字符串只包含十进制数字则返回True，否则返回False
isdigit()如果字符串只包含数字则返回True，否则返回False
isnumeric()如果字符串中只包含数字字符则返回True,否则返回False
isspace()如果字符串中只包含空格则返回True,否则返回False
istitle()如果字符串是标题化（所有的单词都是大写开始。其他小写）则返回True否则返回False

>>> str5 = "FishC"
>>> str5.istitle()
False
>>> str5 = "Fishc"
>>> str5.istitle()
True
>>> 

isupper()如果字符串至少包含一个区分大小写的字符，并且这些字符都是大写则返回True否则返回False

islower()所有的字符都是小写则返回True,否则返回False
>>> str4 = '小甲鱼'
>>> str4.islower()
False

lower()转换字符串中所有的大写字符为小写

lstrip() 去掉左边的空格和换行
>>> str6 ="       I love    you"
>>> str6.lstrip()
'I love    you'
>>> str6
'       I love    you'
>>> 

rstrip()去掉末尾的空格和换行

partition(sub)找到字符串sub，把字符串分成给一个3元祖（pre_sub,sub,fol_sub）,
如果字符串中不包含sub 则返回（'原字符串','',''）

>>> str6 = 'I love fishc'
>>> str6.partition("ve")
('I lo', 've', ' fishc')
>>> str6.partition("dd")
('I love fishc', '', '')
>>> 

replace (old,new[,count])   字符串old字符串替换成new字符串，如果count指定则替换不超过
count次

>>> str6.replace("fishc","FISHC")
'I love FISHC'
>>> str6
'I love fishc'

join(sub):以字符串作为分隔符，来拼接一个可迭代对象
>>> str5.join("1,2,3,4")
'1Fishc,Fishc2Fishc,Fishc3Fishc,Fishc4'
# names = ['czh','ddd','sss']
# print(','.join(names))

split ()不带参数默认以空格为分隔符欺骗字符串，如果maxaplit参数有设置，则仅分割maxsplit个字符串，返回切片后的子字符串拼接的列表
1、按照指定的字符串去分割字符串，然后把每一个放到一个list里
2、如果什么都不写按照空格分割
>>> str6.split()
['I', 'love', 'fishc']
>>> str6.split("i")
['I love f', 'shc']
>>> str6
'I love fishc'

splitlines()以换行符分隔字符串返回一个列表

strip() 去掉左右两边空格和换行，括号里写啥去掉啥
swapcase()转换大小写
translate(table) 根据table原则（可以由str.maketrans(''a,'b')）转换字符串中的字符（前后字符串做映射）

>>> str6.translate(str.maketrans("love","love love"))
Traceback (most recent call last):
  File "<pyshell#21>", line 1, in <module>
    str6.translate(str.maketrans("love","love love"))
ValueError: the first two maketrans arguments must have equal length
>>> str6.translate(str.maketrans("love","hhhh"))
'I hhhh fishc'
>>> 

upper() 转换所有小写为大写
zfill()返回长度为width的字符串，元字符串右对齐，前边用0填充

import string
print(string.ascii_letters)
print(string.ascii_lowercase)
print(string.ascii_uppercase)
print(string.digits)
print(string.ascii_letters+string.digits)

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
0123456789
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789

a = 1
b = 2
不引入第三方变量交换两个变量的值：
a,b =b,a

a = a + b
b = a - b
a = a - b

　　

五、列表和列表操作

上面说了字符串和整形，那现在要是想存一个班级的人的名字，这个班有200个人，怎么存呢，用字符串的话，
那就是names = 'marry lily king .....'这样，但是这样存是可以存，那要是想取到某个人的名字怎么取呢，
不能再去里面看一遍吧，那累死人了，为了解决这个问题，又有一种新的数据类型应运而生，那就是列表
，这也是我们在以后的开发过程中，最常用的数据类型之一，列表也叫数组，列表定义，使用[]即可；
列表里面可以再套列表，一个里面套一个列表，叫二维数组；一个里面套一个列表，里面的列表再套一个列表，
这个叫三维数组，套几层就是几维，定义格式如下：

    list1 = [1,2,3,4] #一个普通的数组
    list2 = ['marry','lily',[50,'monkey']] #二维数组
    list3 = ['name','sex',['lily',124,['aaaa','bbb']]] #三维数组

对列表的操作，分以下几种增、删、改、查

增：1、append末尾增加
   2、expend在末尾使用另一个列表增加
   3、insert在固定位置插入

append()      括号里只能跟一个参数

>>> member.append("娃娃")
>>> member
['小甲鱼', '小布丁', '黑夜', '迷途', '怡静', '娃娃']
>>> 

>>> member.append("竹林","小溪")
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    member.append("竹林","小溪")
TypeError: append() takes exactly one argument (2 given)

append()
方法是将参数作为一个元素增加到列表的末尾。
如果把数组append就直接当做一个元素添加到末尾
names = ['ddd','ssd']
name = ['44','66']
names.append(name)
['ddd', 'ssd', ['44', '66']]
print（name+stus）可以直接把两个列表相加
extend()
方法则是将参数中每一个值作为一个列表去扩展列表的末尾
extend()   使用一个列表来拓展另一个列表

>>> member.extend('竹林小溪','Crazy迷恋')
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    member.extend('竹林小溪','Crazy迷恋')
TypeError: extend() takes exactly one argument (2 given)

>>> member.extend(['竹林小溪','Crazy迷恋'])     #这样就可以以一个列表拓展
>>> member
['小甲鱼', '小布丁', '黑夜', '迷途', '怡静', '娃娃', '竹林小溪', 'Crazy迷恋']
>>>

insert()  在指定位置插入参数
第一个参数是位置，第二个位置是参数值；从0开始
 >>> member.insert(1,'牡丹')
>>> member
['小甲鱼', '牡丹', '小布丁', '黑夜', '迷途', '怡静', '娃娃', '竹林小溪', 'Crazy迷恋']
>>>

　改：

msg = '你好'
            name = ['yy','cc','niuniu']
            name[1] = 'baby' #修改指定位置的值

  查：

 msg = '你好'
            name = ['yy','cc','niuniu']
            print(name[0])#获取第一个元素
            print(name[-1])#-1代表最后一个元素

　删：　

1、remove（） 删除指定的值name.remove('baby')

2、del（）删除指定位置的值 name.del[0]

3、pop（）不传下表的话默认删除最后一个值

4、clear() 清空列表 

remove
>>> member.remove('黑夜')
>>> member
['小布丁', '小布丁', '迷途', '怡静']
>>> 

>>> member.remove("dd")
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    member.remove("dd")
ValueError: list.remove(x): x not in list
>>> 

del
del
>>> del member[1]
>>> member
['小布丁', '迷途', '怡静']

后面跟列表名直接把列表里的数据全部删掉
>>> del member
>>> member
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    member
NameError: name 'member' is not defined
>>> 

pop()弹站的方法删除，从列表中取出最后一个元素并返回
>>> member
['小甲鱼', '小布丁', '黑夜', '迷途', '怡静']
>>> member.pop()
'怡静'
>>> member
['小甲鱼', '小布丁', '黑夜', '迷途']
>>> 

还可以：
name = member.pop()
name
'迷途'

另外还可以指定删除那个一个
>>> member
['小甲鱼', '小布丁', '黑夜', '迷途']
>>> member.pop(1)
'小布丁'
>>> member
['小甲鱼', '黑夜', '迷途']
>>> 

如果超出坐标就会报错
clear()清空列表
names.clear()

slice  切片
列表分片：利用索引值，每次我们可以从列表中获取一个元素，
但是我们总是贪心的，如果一次性需要获取多个元素，有没有
办法实现呢？利用列表分片，我们可以简单实现这个要求
可以得到原来列表的一个拷贝不会改变之前的表
>>> member = ["小甲鱼","小布丁","黑夜","迷途","怡静"]
>>> member[0:2]    #左边的代表开始位置的下标，右边代表结束位置的下标同时右边要-1
['小甲鱼', '小布丁']
>>> member[1:4]
['小布丁', '黑夜', '迷途']
>>> 

  简化：
>>> member
['小甲鱼', '小布丁', '黑夜', '迷途', '怡静']
>>> member[:3]
['小甲鱼', '小布丁', '黑夜']

>>> member[:]
['小甲鱼', '小布丁', '黑夜', '迷途', '怡静']

列表中常见的运算符号：
比较运算符：

列表的比较只比较第0个值，第一个值得比较是True结果就是True
>>> list1 = [456,123]
>>> list2 = [123,12]
>>> list1 > list2
True
>>> list2 = [123,789]
>>> list1 > list2
True
>>> 

列表的拼接
>>> list3 = list1 + list2
>>> list3
[456, 123, 123, 789]

>>> list3 *3
[456, 123, 123, 789, 456, 123, 123, 789, 456, 123, 123, 789]

列表中有列表的判断
>>> list5 = [456,["小甲鱼","毛傲"],333]
>>> 456 in list5
True
>>> '456' in list5
False
>>> '小甲鱼' in list5   # 因为‘小甲鱼’属于位置1的列表所以必须指定位置后才能访问
False
>>> '小甲鱼' in list5[1]
True

访问列表中的列表元素：
>>> list5
[456, ['小甲鱼', '毛傲'], 333]
>>> list5[1][1]
'毛傲'
>>> 

count 统计123出现的次数
>>> list3.count(123)
2
>>> list3
[456, 123, 123, 789]

index，确定列表元素的位置可以限定范围，有好几个的话返回第一个的坐标
>>> list3
[456, 123, 123, 789]
>>> list3.index(123)
1
确定元素所在的范围的位置
>>> list3.index(123)
1
>>> list3.index(123,0,2)   #123代表目标原色，0是代表起始位置，2代表末位置
1
>>> list3.index(123,2,3)
2
>>> 

print（name+stus）可以直接吧两个列表相加

reverse：逆转反转
>>> list3
[456, 123, 123, 789]
>>> list3.reverse()
>>> list3
[789, 123, 123, 456]
>>> 

sort 排序（默认从小到大排序）

>>> list4 = [0,1,88,5,7,6,4,3,4,1]
>>> list4.sort()
>>> list4
[0, 1, 1, 3, 4, 4, 5, 6, 7, 88]
倒叙
>>> list4
[0, 1, 1, 3, 4, 4, 5, 6, 7, 88]
>>> list4.sort(reverse= True)
>>> list4
[88, 7, 6, 5, 4, 4, 3, 1, 1, 0]

清空列表的元素：  clear   清空后列表还存在只是内容为空
>>> list1.clear
<built-in method clear of list object at 0x02C84DC8>
>>> list1.clear()
>>> list1
[]

copy和切片功能类似：
>>> list4
[88, 7, 6, 5, 4, 4, 3, 1, 1, 0]
>>> list4.copy()
[88, 7, 6, 5, 4, 4, 3, 1, 1, 0]
 坐标 -1就是最后一个值

　　六、元祖

戴了枷锁的列表tuple

    和列表的区别：1.列表可以随便改变元素，但是元祖不能修改，不能随意插入删除元素

                           2.创建元祖大部分用小括号

 

读取和列表一样
>>> tuple1=(1,2,3,4,5,6,65,6,)
>>> tuple1[1]
2

>>> tuple2 = tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5, 6, 65, 6)

>>> x,y,z = 1,2,3
>>> type(x)
<class 'int'>
touple关键符号是，号

>>> temp = 1,2,3,4
>>> type(temp)
<class 'tuple'>
创建空元祖：
>>> temp = ()
>>> type(temp)
<class 'tuple'>

>>> 8*(8)
64
>>> 8*(8,)
(8, 8, 8, 8, 8, 8, 8, 8)

中间插入一个元素,逗号和小括号必须同时存在
>>> temp
('小甲鱼', '黑夜', '迷途', '小布丁')
>>> temp = temp[:2]+("哈哈",)+temp[2:]
>>> temp
('小甲鱼', '黑夜', '哈哈', '迷途', '小布丁')

删除整个元祖：del
del temp
>>> temp
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    temp
NameError: name 'temp' is not defined

只有  index和 count两个方法
强制类型转换：
list  int  float  str   tuple

　　七、字典

面说了，整形、浮点型、字符串、列表和元组，下面说个新的数据类型，字典，字典也是我们开发过程中最常用的一种数据类型；想一个问题，现在要存整个北京市的所有人的信息，每个人有姓名、年龄、性别、家庭住址、学历等等，那要是用列表存的话，那就得定义N多个数组，然后存上每个人的信息，那累死人了。。。这时候又有一种新的数据类型出现了，那就是字典，dict，全称是dictionary，它具有极快的查找速度；字典是一种key-value的数据类型，比如说要存每个人的信息，那么每个人的编号就是key，value就是每个人的信息，这样的话，一个字典就能存所有人的信息了。字典的定义使用{}，大括号，每个值用“，”隔开，key和value使用“：”分隔。

举个列子，如果用列表存每个人的信息的话，需要用两个列表，一个存人名，一个存信息：

    names = ['marry','amy','lily']
    infos = [[18,18612512981,'北京'],[20,18612512991,'山东'],[25,18612532981,'河南']]
给一个名字，如果要查他的对应信息，那就要先从names里面找到它的位置，然后再从infos中找到它的信息，如果这个列表越长，那么它的查询速度越慢。

如果用字典实现的话，只需要一个名字和信息对应的一个表，这样就很快的根据名字找到它对应的信息，无论这个表有多大，查找速度都不会变慢。

        infos = {'marry':[18,18612512981,'北京'],'amy':[20,18612512991,'山东'],'lily':[25,18612532981,'河南']}
        infos['marry'] #取marry的信息
为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢，这种就是字典的实现方式。

　　

字典
#字典
#字典的特性：
#字典是无序的，因为它没有下标，用key来当索引，所以是无序的
#字典的key必须是唯一的，因为它是通过key来进行索引的，所以key不能重复，天生就去重
info = {
    'name':'xiaoming',
    'sex':'nan',
    'age':'20',
    'id':1
}
# print(info)

#取值@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
# print(info['name'])  #通过key取值
# #用[]和get方法取值的区别：get方法 获取不到时会返回一个None,[]会报错
# print(info.get('name')
# print(info.get('addr','beijing'))  #get还可以 传一个 默认参数

#增加@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
# info['addr'] = 'beijing'
#给字典新增一个key
# print(info)
# info.setdefault('phone',13333333)
# print(info)

#修改
# info['id'] = 7
# print(info)
# #有这个key的话就是修改没有的话就是新增
# print(info)
#删除
# del info['addr']
# print(info)
# info.pop('name')  #字典时无序的,所以必须指定key值,并会返回key对应的 value值,pop删除的key必须存在 不然会报错

# info.popitem()#随机删除一个key值
# print(info)
#info.clear  #清空字典

# new_infos = [
#     {
#         'yangwb':{
#             'id':1,
#             'sex':'other',
#             'phone':'250'
#         },
#         'yangwn':{
#             'id':2,
#             'sex':'other',
#             'addr':'huoxing'
#         },
#         'hhh':{
#             'id':'3',
#             'money':'2000',
#             '不知道':'vvvvv'
#         }
#     }
# ]
字典的内置方法：
# print(new_infos[0].get('yang wn').get('addr'))
# print(info.keys())  #获取所有的 key
# print(info.values())#获取所有的 value
# print(info.intems)#打印所有的key和value返回一个list
info.update(info2)  #把两个字典合并到一起如果有一样的key更新 value

#循环取所有的值 

1、# for i in info: # print(i,info[i]) # 
2、# for u,v in info.items(): # print('%s is %s'%(u,v))不推荐，因为需要把字典转成一个列表效率不高
info2 = { 'name':'yyy', 'sex2':'nan', 'age2':'20', 'id':1 } #在python3中直接用in 判断key是否存在 print('name' in info)

　　

集合：
集合也是一种数据类型，一个类似列表东西，它的特点是无序的，不重复的，也就是说集合中是没有重复的数据
集合的作用：
1、它可以把一个列表中重复的数据去掉，而不需要你再写判断
2、可以做关系测试，比如说有两个班，一个性能测试班，一个是接口测试班的，想找出来既学习了性能又学习了接口测试的同学，就可以用集合
定义集合：

res =set()定义空集合

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'}#这种方式是直接定义一个集合

　集合操作：

list1 = {1, 2, 3, 4, 5, 6, 9}
        list2 = {2, 3, 4, 6, 1}
        list3 = {1, 2, 3}
        print(list1.intersection(list2))  # 取交集，也就是取list1和list2中都有的
        print(list1 & list2)# 取交集
        print(list1.union(list2))  # 取并集，也就是把list1和list2合并了，然后去除重复的
        print(list1 | list2)# 取并集
        print(list1.difference(list2))  #取差集 在list中存在，在list2中没有的
        print(list1 - list2)
        print(list3.issubset(list1))#判断list3是不是list1的子集
        print(list1.issuperset(list3))#判断list1是不是list3的父集
        print(list1.isdisjoint(list3))#判断list1和list3是否有交集
        print(list1.symmetric_difference(list2))#对称差集，输出两个列表中都没有的值，也就是把两个集合中相同的去掉
        print(list1 ^ list2)
        list1.add(888)#添加元素
        list1.update([777,666,666])#添加元素
        list1.remove(777)#删除元素，如果元素不存在会报错
        list1.pop()#删除一个随机的元素，并返回删除的元素
        list1.discard('dddd')#如果删除的元素存在，删除，不存在不做