3. python 基本数据类型

Python 的基本数据包括以下几种：

数字

Python3 支持 int、float、bool、complex（复数）。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

布尔值

#非空即真，非零即真。
x =0     #在整型中除了0是False，负数以及正数都是True
y =[]    #空列表为False，反之为True
z=''     #空字符串为False，反之为True
print(bool(x),bool(y),bool(z))

False False False

字符型 String

# 常用的字符串方法：
a = '\n      字 符  串      \n'
c= a.strip()  #默认去掉字符串前后的空格和换行符
c= a.lstrip()   #默认去掉字符串前面的空格和换行符
c= a.rstrip()   #默认去掉字符串后面的空格和换行符

a = 'pythton'
print(a.count('t'))
print(a.index('t')) #找的第一个的下标
print(a.find('t'))
print(a.replace('t','T'))
print(a.isdigit())  #是否全是数字
print(a.islower())#是否全都是小写字母
print(a.isupper())#是否全都是大写字母
print(a.isalpha())#是否全都是汉字或者字母
print(a.isalnum())#是否为汉字或者数字或者字母，只要特殊字符就返回Fales，判断特殊字符
print(a.upper())
print(a.lower())
print(a.startswith('test')) #以xx开头
print(a.endswith('.xls')) #以xx结尾

a.zfill(9)  #在字符串 a 前补0，使其字符个数达到 9

#以下两个方法最牛逼
1.列表转换成字符串
''.join('') #连接字符串，只能对列表进行操作，把列表中的元素连接成一个字符串。
l = ['a','b','c','d']
res = ''.join(l) 

2.把字符串转换成列表
#split()，只能对字符串进行操作，根据某个字符（字符串），分割字符串，变成list
name = 'aaa,bbb,ccc,ddd'
name_list = name.split(',')
print(name_list)

#大小写字母、数字、特殊字符
import string
print(string.ascii_letters)#所有的大、小写字母
print(string.ascii_lowercase)#所有的小写字母
print(string.ascii_uppercase)   #所有的大写字母
print(string.digits)    #所有的数字
print(string.punctuation)    #所有的特殊字符

#format方法：实现变量名指定传输
user= 'AAA'
sex = '男'
age = 18
addr = '深圳'
money = '一千万'
car = '劳斯莱斯'
#对应插入方法：
words = 'insert into user values ("%s","%s","%s","%s""%s","%s")' %(user,sex,age,addr,money,car)
print(words)
#format方法
sql = 'insert into user values ("{name}","{sex}","{age}","{qian}","{che}","{addr}")'
new_sql = sql.format(age=age,che=car,name=user,sex=sex,qian=money,addr=addr)
print(new_sql)

列表

（列表： list / 数组 / array），编号叫下标 / 索引 / 角标

最前面一个元素的下标时0，最后面一个元素的下标是 -1

cities=[]  #定义一个空的列表
#增加元素
cities.append('北京')  #在列表末尾增加一个元素
cities.insert(0,'上海')  #在指定的位置插入一个元素，一次只能加一个。

#删除元素
cities.pop(-1)  #删除指定的元素，传下标
cities.remove('北京')  #删除指定的元素，传元素
cities.clear()  #清空列表
del cities[-1]  #删除指定位置的元素，传下标

#修改
cities[1] = '南京'   #指定某一个下标，直接修改即可，指定下标不能超出已有下标范围。

#查询
print(cities)  #打印整个列表
print(cities[0])   #打印指定位置的元素
print(cities.index('广州')   #获取元素的下标，如果元素不存在，则报错
print(cities.count('广州')  #查看元素在list 出现了几次
print(cities.reverse())  #返回None，但把列表反转了要重新print(cities)才能看到结果，如下：
cities.reverse()　　#将cities 反转
　　print(cities)   #打印cities
cities.sort()   #默认升序排序
cities.sort(reverse=True)   #降序排序，按数字或字母排序
print(cities1 + cities2)  #合并list
#切片，切片是list取值的一种方式
print(nums[1:3]) #切片只顾头不顾尾，即取下标1到3（不包括3）。
print(nums[1:]) #如果从某个下标开始取到末尾，末尾的下标可以省略
print(nums[:2]) #如果是从头开始取，取到后面某个下标（不包括）结束，开头的下标可以不写
print(nums[:]) #取出全部

列表排序的3种方法：
list.reverse()

random.shuffle(list)

list.sort()

#循环
for i in range(1,4): #range()也是顾头不顾尾
    print(i)    #打印结果：1、2、3

lis= list(range(1,21))  #类型转换为list
print(lis)　　　　　　　　#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

#步长
lis= list(range(1,21))
print(lis[1:10:2])   #步长，隔2个取一个数字，到第9个下标

lis= list(range(1,21))
print(lis[::-1])   #如果步长时正数的话，就从左到右取值，如果步长为负数，则从右到左取值。相当于把列表反转。与.reverse()的区别是：.reverse()改变了列表的内容。
#当步长为负数时，a:b:-1，a（正）必须大于b（正），否则取值为空
例如：
lis= list(range(0,21))
print(lis)
print(lis[21:10:-1])  #从下标21到下标10取值，但不包含10的下标：[20, 19, 18, 17, 16, 15, 14, 13, 12, 11]
print(lis[:18:-1])  #从下标最大到下标18取值，但不包含18的下标：[20, 19]
print(lis[0::-1])  #从下标0到最小下标取值，只取0的下标：[0]
print(lis[::-1])    #从下标最大取到最小：[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

s = 'abcdefghi'
s[3] ='h'  #字符串变量不可以修改，报错：TypeError: 'str' object does not support item assignment

lists = ['AAA','BBB','CCC','DDD']
for name in lists:   #循环读取数组中的每一个元素
    print(name)

words = 'marry,lily,joker'
for name in words:    #循环读取字符串中的每一个字符
    print(name)
# for 循环在循环可迭代对象的时候，每次循环的是里面的每一个元素。

#如果是一个多维数组，则要判断类型。
lists = ['AAA','BBB','CCC','DDD',[1,2,3,4]]
for name in lists:
     if type(name) == list:　　
         for i in name:　　
             print(i)　　#打印列表中的列表：1 2 3 4

元组

元组也是一个list，它和 list 的区别是，元组里面的元素无法修改

t = ('aaa','bbb','ccc','ddd','ee')
print(type(t))  #<class 'tuple'>
print(t[:3])  #元组的切片:('aaa', 'bbb', 'ccc')
print(t[4:])    # ('ee',) 输出在元素后面加一个逗号，代表元组

#元组只有这两种方法，元组不能被修改。
print(t.index('aaa'))   #找到元素的下标
print(t.count('aaa'))   #找到元素的个数    

t2 =(1,2,4)
words = (1)
words2 = ('abc')
print('t2',type(t2))    #t2 <class 'tuple'>
print('words',type(words))  #words <class 'int'>
print('words2',type(words2))    #words2 <class 'str'>
#如果元组里面只有一个元素的话，那么你必须在这个元素后面加一个逗号，才能成为元组。

字典

字典是 key - vaule 的形式

1. 取数据方便

2. 速度快

ifos ={'name':'AAA','sex':'男','age':18}
# 查：字典取值就这两种方式：
print(ifos.get('name')) #如果key不存在，则返回None
print(ifos['name'])    #如果key不存在，则报错
print(ifos.get('aaa','phone')) #指定如果取不到aaa这个key时，默认phone，这是get的另一种方法
#增
ifos['phone']=1852003000 #字典是无序的，添加的值不一定在最后，如果key存在，则是修改
ifos.setdefault('height','BBB')    #增加字典的另一种方式
#改
ifos['name']='YYYY' #如果key已存在，用这种方式可以修改name的值，仅此一种
ifos.setdefault('name','EBB')    #如果key已存在，用这种方式不能修改name的值
#删除
ifos.pop('age') #指定key来删除
ifos.popitem()  #随机删除一个key
del ifos['phone']   #指定key来删除
ifos.clear() #清空字典

字典内置的方法：
print(ifos.values()) #获取到字典所有的value：dict_values(['AAA', '男', 18]：
print(ifos.keys())   #获取到字典的所有的key：dict_keys(['name', 'sex', 'age'])
print(ifos.items())  #获取到字典的所有的k-v：dict_items([('name', 'AAA'), ('sex', '男'), ('age', 18)])

#循环

for p in people:
    print(p)    #循环字典时，打印的时字典的key


for k,v in people.items():
    print(k,'=====>',v)  #循环时同时取key和value

for k in people.items():
    print(k)  #循环打印出每一个key的所有值

#TEAM 是一个字典，它的值也是一个字典，如何取值？
TEAM = {
    'a': {'A': 'B'},
    'b': {'C': 'D'},
}

TEAM['b'].setdefault('X','Y')   #在key:b 的value中增加k-v
print(TEAM)  
{'a': {'A': 'B'}, 'b': {'C': 'D', 'X': 'Y'}}

for v in TEAM.values(): #打印出values
     print(v)   
{'A': 'B'}
{'C': 'D', 'X': 'Y'}

for k in TEAM.items():    #打印出TEAM的k-v
     print(k) 
('a', {'A': 'B'})
('b', {'C': 'D', 'X': 'Y'})  

for k,v in TEAM.items():   #打印出k,v
     print(k,v)  
a {'A': 'B'}
b {'C': 'D', 'X': 'Y'}

for i in TEAM.keys():   #
    for k,v in TEAM[i].items():   #
        print(i,k,v)  
a A B
b C D
b X Y

 集合 set

#集合的特点：天生去重，集合也是无序的。

s = set() #定义一个空集合
s2 = set('12344455667788')
s3 = {1,1,3,4,5,6,7}
s4 = {'1','2','3','4'}

print(s2)

#集合还可做关系测试：交集、并集、差集，只有集合才可以做交集、并集、差集操作，其他类型会报错。
print(s3 & s2) #打印为：set()，是因为 s2 中都是字符，s3 是整型。
print(s4 & s2) #取交集
print(s4.intersection(s2)) #取交集

#并集
print(s2 | s3)
print(s2.union(s3))

#差集，取一个集合存在，另一个不存在的元素
c1 = {1,2,3}
c2 = {1,4,6}
print(c1-c2) #{2, 3}
print(c2-c1)  #{4, 6}
print(c2.difference(c1))  #{4, 6}

#对称差集，去掉两集合里面都存在的，取不重复的。
print(c1^c2) #{2, 3, 4, 6}
print(c1.symmetric_difference(c2))

c1.add('ss')  #加元素
print(c1)
c1.pop()  #随机删一个元素
print(c1)
c1.remove('ss') #指定删除
print(c1)
c1.update({5,6,7})  #把另一个集合加进去
print(c1)

#也可以用isdisjoint这个方法判断交集。