python基础数据类型

一、数据类分类

数据类型分类：
    不可变的数据类型(可哈希)：str，bool，tuple，int
    可变的数据类型：dict，list，set。
    容器类数据类型：list，tuple，dict，set.
二、基础数据类型
2.1 int
用于计算

int
i=1
# i=5
print(i.bit_length())# 十进制转二进制有效占位数

'''
二进制              十进制
0000 0001           1
0000 0010           2
0000 0011           3
0000 0100           4
0000 0101           5
'''

2.2 bool

布尔值就两种：True，False。就是反应条件的正确与否。

'''
int ---->str :str(int)
str---->int :int(str)


int ---->bool 0 False 非零 1 True
str ---> bool '' False 非空True 
'''
print(bool("")) #False
print(bool("  ")) #True（不是空字符串，有空格）

 

2.3.str　

2.3.1字符串的索引与切片

#索引

s="python运维21期"

s1=s[-1:-4:-1]
print(s1)
s2=s[-3]
print(s2)
s4=s[0:5:3]
#切片

# s[起始索引:结束索引+1:步长]

s5=s[::-3]
print(s5)

print(len(s))
s6=s[-1:-12:-1] #倒着取值，必须加反向步长
print(s6)

2.3.2字符串的常用方法

#*** strip 去除首尾的空格，制表符\t,换行符。不仅仅是去除空格...
#lstrip() rstrip()
t="\trobin\n"
print(t)
print(t.strip())

t1=" robin "
print(t1.lstrip())#只去左空格

t2=" robin\n "
print(t2.rstrip())#只去右换行符


#*** split  (str ---> list)

 t1="tom zhangsan lisi"
 print(t1.split())
 s = 'oldboywusiroalex'
 s11=s.split('o')
 print(s11)

#join 将list --->str

l=["tom","zhnagsan","lisi"]
l1=','.join(l)
print(l1,type(l1))

#格式化输出format

#方式一
res1 ='{} ,{},{}'.format("tom","43","run")
print(res1)

#方式二
res2='my name is{0} ,my age is{1},my hobbiess is{1}'.format("tom","22","run")
print(res2)
#方式三
res3='my name is{name} ,my age is{age},my hobbiess is{hobbiess}'.format(age="22",hobbiess="run",name="tom")
print(res3)

# *** startswith 判断是否以...开头 
#endswith 断是否以...结尾

t="robin"
print(t.startswith('ro')) 
print(t.startswith('ro',2,4))

print(t.endswith('in'))
print(t.endswith("bin",2,5))
 
#is系列
name="tom123"
print(name.isdigit())#字符串只由数字组成
print(name.isalnum())#字符串由字母或数字组成
print(name.isalpha())#字符串只由字母组成


#*** upper 小写变大写  lower大写变小写
s='toM'
s2=s.upper()
s3=s.lower()
print(s2,s3)

#用户登录验证码例子

code="wqWGH".lower()
choeck=input("请输入图上验证码：").lower()
if choeck ==code:
    print("验证成功")
else:
    print("验证码错误")
 
# *capitalize 首字母大写后面全部小写
s='toM'
s1=s.capitalize()
print(s1)
 
#* 大小写反转 swapcase()

s="Qert"
print(s.swapcase())



#*非字母的元素隔开的每个单词首字母大写 title()

t="tom welcome to bj"
print(t.title())


# center 居中，长度自己设定，默认填充物None

t="robin"
print(t.center(20))
print(t.center(20,"*"))

# #replace 替换

s = '马老师就你皮fdsalj马老师你是真的秀'
s66=s.replace("马老师","中山桥扛把子")
print(s66)
#find 通过元素找索引  找不到返回-1
# index 通过元素找索引 找不到报错
s = 'Robin'

s88=s.find("in")
print(s88)

s87=s.find("lk")
print(s87)

s66=s.index("lh")
print(s66) #找不到会报错

s69=s.index("o")
print(s69)

#公共方法：len count

s = 'fdsafsdagsdafjdskahdhjlsadhfkj'
print(len(s))#统计字符串的个数

s1 = 'fdsadd'
print(s1.count('d')) #统计字符串某个元素出现的个数

　2.4 列表 list

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

　　l=["tom","天明","机关兽",123,"巨子"]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

2.4.1 增 

#append在最后增加
l.append("高渐离")
print(l)

# insert插入
l.insert(-1,"苍老师")
print(l)

#迭代着添加
l.extend("opt")
print(l)
l.extend(123,345,678)
print(l)

2.4.2  删

#del 切片删除

del l[:3]
print(l)
#pop 删除list唯一有返回值的方法
l1 = li.pop(1) #按照位置去删除，有返回值
print(l1)
#del 切片删除
del l[:3]
print(l)
print(l)

#clear
# l.clear()#清空列表
# print(l)

2.4.3  改 

l=["tom","天明","机关兽",123,"巨子"]
#按照索引改
l[1]="Robin"
print(l)

#按照切片去改
print(l[-1:-4:-1])

l[-1:-4:-1]=["11","12","ojk"]
print(l)

 

2.4.4 查

# 查
#按照索引去查询，按照切片去查询
for i in l:
    print(i)

2.4.5 其他方法

count（数）（方法统计某个元素在列表中出现的次数）。

l=["tr",123,"234","str"]
print(l.count("tr"))

index（方法用于从列表中找出某个值第一个匹配项的索引位置）

#通过元素找索引
l=["tr",123,"234","str"]
print(l.index("123")) #找不到会报错

print(l.index("234"))

 

排序（sort） 注：数字排序，字符串没意义

num1=[]
num=[9,37,66,-2]
num1=num.sort()#从小到大排序
print(num1)

print(num.sort(reverse=True))#从大到小排序
print(num)

reverse （方法将列表中的元素反向存放）。

#reverse 列表的元素取反
l=["tom","天明","机关兽",123,"巨子"]
l.reverse()
print(l)

 2.5 字典dict

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

　　字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

典的key是唯一的。key 必须是不可变的数据类型。

字典：存储数据多，关系型数据，查询速度快（二分查找）。
3.6版本之前，字典是无序的，3.6之后字典是有序的。

 2.5.1、 增

dict={"name":"tom","age":15,"hobbies":"swimng"}
 dict["weight"]="70"有则覆盖，无则添加
print(dict)

 dict.setdefault("age1",88) #有则不变，无则添加
 print(dict)

 

 

 2.5.2、删 

dict={"name":"tom","age":15,"hobbies":"swimng"}
dict.pop("age")# 返回值 对应的值
print(dict)


print(dict.popitem()) #随机删除，返回值
print(dict)


dict.clear() # 清空
print(dict)

del  dict
print(dict)

del  dict["age"]
print(dict)

2.5.3、改

dict["name"]="lisi"
print(dict)


dict1={"name":"zhangsan","weight":65}
dict.update(dict1) #将dict1的键值对覆盖添加到dict中，dic  1不变。
print(dict)
print(dict1)

2.5.4、查

print(dict.get("name"))
print(dict.get("name3"))
print(dict.get("name3","没有key"))

 

 2.5.5    循环

#keys() values() items()#keys() values() items()
##keys()
dict={"name":"tom","age":15,"hobbies":"swimng"}
for key in  dict:
    print(key)


#items list ---->一个个小元祖
print(dict.items())
 print(dict.items())
for k,v in  dict.items():
    print(k,v)



# print(dict.values())#支取字典中的values
for v in dict.values():
    print(v)

2.6 元祖

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）注：元祖内嵌套的list dict 可以增删改

2.6.1元祖基本操作

tun=(11,22,33,["tom","2132"],{"name":"zhangsan","age":15})
print(tun[-1:-3:-1]) #反向取元祖元素的值
print(tun[0])
print(tun.count(22)) #统计元祖某个元素的出现的次数
print(len(tun))
tun[-2].append("wangwu")
print(tun)
tun[-1]["name1"]="ermao" #修改元祖中list中的值
print(tun)

 

2.7集合

集合：
    无序，不重复的数据类型。它里面的元素必须是可哈希的。但是集合本身是不可哈希的。
    1：关系测试。交集并集，子集，差集....
    2,去重。（列表的去重）
'''

2.7.1 增

#增
s1={"1112",22,55}
print(type(s1))
s1.add("tom")
print(s1)

 

 2.7.2 删

set1 = {'alex','wusir','ritian','egon','barry'}
#按照元素删除
# set1.remove("egon")
# print(set1)
#pop 随机删除一个元素
# set1.pop()
# print(set1)

2.7.3 清空集合

 

#clear 清空集合
# set1.clear()
# print(set1)

2.7.5 删除集合

# del  set1
# print(set1)

 

2.7.6 关系测试

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

#交集 &  intersectio
# print(set1 & set2)
# print(set1.intersection(set2))

#并集 |   union
# print(set1 | set2)
# print(set1.union(set2))

#差集  -  difference
# print(set1 - set2)
# print(set2.difference(set1))

#反交集 ^ symmetric_difference
# print(set1 ^ set2)
# print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}
# set1 = {1,2,3}
# set2 = {1,2,3,4,5,6}

# print(set1 < set2)
# print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

# print(set2 > set1)
# print(set2.issuperset(set1))

# s = frozenset('barry')
# s1 = frozenset({4,5,6,7,8})
# print(s,type(s))
# print(s1,type(s1))

2.8小数据池

python中 有小数据池的概念。
int -5 ~256 的相同的数全都指向一个内存地址，节省空间。
str：s = 'a' * 20 以内都是同一个内存地址
只要字符串含有非字母元素，那就不是一个内存地址

#深浅copy
#赋值运算，它们共用一个列表
# a = [1,2,3]
# b = a
# a.append(666)
# print(a,b)

2.8.1 浅copy

 

l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l1,l2)
print(id(l1),id(l2))

l1 = [1,2,3,[22,33]]
l2 = l1.copy()
l1[-1].append(666)
print(l1,l2)
print(id(l1[-1]),id(l2[-1]))

 

2.8.2. 深copy

import copy
l1 = [1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1,l2)
print(id(l1[-1]),id(l2[-1]))

 2.8.3 深浅copy的区别

 

　浅copy：

对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，
指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性

深copy：

对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变