Python基础二

Python基础二（数据类型介绍）

一、引言

　　1 、什么是数据？

　　　　x=10，10是我们要存储的数据

　　2 、为何数据要分不同的类型

　　　　数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

　　3 、数据类型

　　　　　　数字

　　　　　　字符串

　　　　　　列表

　　　　　　元组

　　　　　　字典

　　　　　　集合

 

二、基础数据类型

　　1、数字int：用于计算

　　　　int（整型）-- 12,3,45 
　　　　+ - * /  //
　　　　% 取余数、** 幂、// 整除

　　　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1

　　　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1

　　　　Python3里不再有long类型，全是int型

　　　　还有float--浮点型, 复数型：(略)　

　　　　.bit_length() -- 十进制转二进制后的位数

i = 100
print(i.bit_length())  # 7

　　2、布尔值bool：用于判断

　　　　布尔值    True    False

　　　　数字转换bool：0--False    非0--True 

i = 3
b = bool(i)
print(b)  # True

　　　　bool转换数字：False--0    True--1

b = True
i = int(b)
print(i)  # 1

　　　　PS -- while 1： 比  while True： 效率高

　　3、字符串str：存储、操作少量字符

　　　　str -- python当中凡是用引号（单、双、三）引起来的都是字符串。

　　　　可相加:  字符串的拼接，双方都只能是字符串。

i = 18
print('今年' + str(i) + '岁')

　　　　可相乘：str * int，重复字符串

print('坚强' * 8)

　　　　字符串转化成数字：int(str) 条件：str必须是数字组成的

s = '123'
i = int(s)

　　　　数字转化成字符串：str(int)

i = 1
s = str(i)

　　　　字符串转化成bool：空字符串--False 、非空字符串--True

s = input('请输入：')
if s:
    print('输入不为空！')
else:
    print('你输入的为空，请重新输入！')

　　　　字符串索引与切片：

　　　　索引即下标，就是字符串组成的元素从第一个开始，初始索引为0，以此类推

a = 'ABCDEFGHIJK'
print(a[0])  # A
print(a[3])  # D
print(a[-1]) # K
print(a[-2]) # J

　　　　切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾尾）

a = 'ABCDEFGHIJK'
print(a[0:3])    # ABC
print(a[2:5])    # 默认步长1
print(a[0:])     # 默认到最后
print(a[0:-1])   # -1是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[0:5:2])  # 加步长
print(a[5:0:-2]) # 反向步长

　　　　字符串常用方法：

# capitalize,title,upper,lower,swapcase
name = 'william-Shaw'
print(name.capitalize())  # 首字母大写 William-shaw
print(name.title())  # 每个隔开(字符、数字)单词的首字母大写 William-Shaw
print(name.upper())  # 全字母大写
print(name.lower())  # 全字母小写
print(name.swapcase())  # 大小写翻转

# 居中:总长度，空白处填充
print(name.center(20,"*"))  # ****william-Shaw****
 
# 数字符串中的元素出现的个数。
print(name.count("i",0,4))  # 可切片

# 长度--字符个数
print(len(name))

# 	前面的补全
# 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，
# 如果tab键前面的字符长度超过8个不足12个则补全12个，以此类推。
s1 = "shaw	"
print(s1)
s2 = "shaw"
print(s2.expandtabs())  # 效果同 	

s3 = "dkfjdkfasf54"
# startswith 判断是否以...开头
# endswith 判断是否以...结尾
print(s3.endswith('jdk',3,6))    # T 顾头不顾腚  返回的是布尔值
print(s3.startswith("kfj",1,4))  # T

# 寻找字符串中的元素是否存在
print(s3.find("fjdk",1,6))   # 2 返回的找到的首个元素的索引，如果找不到返回-1
print(s3.index("fjdk",4,6))  # 报错 返回的找到的元素的索引，找不到报错。

# split 以...为分割，最终转换成一个列表，此列表不含有这个分割的元素。
print('title,Title,atre,'.split(','))  # ['title','Title','atre','']
print('title,Title,atre,'.rsplit(',',2))  # ['title,Title','atre','']

# format的三种玩法 格式化输出
s = '{} {} {}'.format('egon',18,'male')  # 顺序填充
s = '{1} {0} {1}'.format('egon',18)  # 按索引填充
s = '{name} {age} {sex}'.format(sex='male',name='egon',age=18)  # 按名称填充

# strip 去空格
name = '&william**'
print(name.strip())  # 默认去除两端空格
print(name.strip('*&'))   # william
print(name.lstrip('*&'))  # william**
print(name.rstrip('*&'))  # &william

# replace 替换
name = 'willam say : my name is william'
print(name.replace('william','bill'))
print(name.replace('william','bill',1))

# is系列
name = 'william123'
print(name.isalnum())  # T 字符串由字母或数字组成
print(name.isalpha())  # F 字符串只由字母组成
print(name.isdigit())  # F 字符串只由数字组成

　　4、列表list：存储、操作大量数据

　　　　list -- [  ，，]　　　　

　　　　列表是python中的基础数据类型之一，里面可以存放各种数据类型

　　　　比如：li = ['bill', 123, Ture, (1,2,3,'bill'), [1,2,3,'小明', ], {'name':'bill'}]

　　　　列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据

　　　　32位python的限制是 536870912 个元素

　　　　64位python的限制是 1152921504606846975 个元素

　　　　列表是有序的，有索引值，可切片，方便取值（同字符串）：

li = ['bill', 123, Ture, (1,2,3,'bill'), [1,2,3,'小明', ], {'name':'bill'}]
l1 = li[0]
print(l1)
l2 = li[1]
print(l2)
l3 = li[0:3]
print(l3)

　　　　增：对原列表进行操作

li = [1,'a','b',2,3,'a']
li.insert(0,55)  # 按照索引去增加-添加到索引位置
print(li)

li.append('aaa')  # 增加到最后
li.append([1,2,3]) 
print(li)

li.extend(['q,a,w'])  # 迭代的去增-必须是可迭代对象
li.extend(['q,a,w','aaa'])
li.extend('abc')
li.extend('a,b,c')
print(li)

# 持续添加输入元素（输入Q退出）
li = []
while 1:
    username = input('>>>')
    if username.strip().upper() == 'Q':
        break
    li.append(username)
print(li)

　　　　删：

l1 = li.pop(1)  # 按照索引去删除，有返回值
l2 = li.pop()  # 默认删除最后一个非空元素
print(l1，l2)

del li[1:3]  # 按照索引去删除，可切片删除，没有返回值
print(li)

li.remove('a')  # 按照元素值去删除，无返回值
print(li)

li.clear()  # 清空列表-- []

del li  # 完全删除列表

　　　　改：(无 replace())

li = [1,'a','b',2,3,'a']
li[1] = 'dfasdfas' # 按照索引去修改
print(li)
li[1:3] ='fdssf'  # 按照切片迭代修改
print(li)
li[1:3] = [1,2,'dde']
print(li)

　　　　查：按照索引、切片、循环去查

for i in li:
    print(i)

　　　　其他操作：len、count、index（无find）、sort、reverse、join

# len 统计长度
li = ["q","w","q","r","t","y"]
l = len(li)
print(l)

# count（数）（统计某个元素在可迭代对象中出现的次数）
print(li.count("q"))

# index （用于从可迭代对象中找出某个值第一个匹配项的索引位置）
print(li.index("q"))

# sort （用于在原位置对可迭代对象进行排序）
li = [2,1,3,4,5]
li.sort()  # 正向排序--没有返回值，只能打印li
print(li)
li.sort(reverse = True)  # 反向排序--没有返回值
print(li)

# reverse （将可迭代对象中的元素反向存放）
li = [2,1,3,4,5]
li.reverse()  # 列表反转--没有返回值，只能打印a
print(li)

# join  (将可迭代对象每个元素用字符串连接，形成新字符串)
# 列表转化成字符串  list -----> str
li = ['bill','shaw','william',123,321]
s = '++'.join(li)
print(s,type(s))

　　　列表的嵌套：嵌套可迭代对象

li = ['william','武藤','常昊',['bill',87],23]
print(li[1][1])

li[0] = li[0].capitalize()
li[0][0] = li[0][0].lower()

li[2] = li[2].replace('昊','日天')
li[2] = '常日天'

li[3][0][0] = li[3][0][0].upper()

print(li)

　　5、元祖tuple：存储只读数据

　　　　tuple -- (  ，，)

　　　　元组被称为只读列表，即数据可以被查询，但不能被增删改

　　　　元素（儿子）不能改，但元素里的元素（孙子）可能被修改

tu = (1,2,3,'bill',[2,3,4,'william'],'shaw')

# 查询和遍历
print(tu[3])
print(tu[0:4])
for i in tu:
    print(i)

tu[4][3]=tu[4][3].upper()  # 列表元素'william'改成大写
print(tu)

tu[4].append('SB')  # 列表可追加
print(tu)

　　　　

　　6、字典dict：存储、操作关系型数据（键值对形式）

 　　　　dict -- {  k : v，k : v，k : v }

　　　　字典是python中唯一的映射类型，采用键值对（key-value）形式存储数据

　　　　python对key进行哈希函数运算，根据计算的结果决定value的存储地址

　　　　字典是无序存储的，key必须是不可变数据类型（可哈希），如：

　　　　　　数字、字符串、布尔值、元祖

　　　　字典当中的元素是通过键key来存取的，而不是通过偏移存取。

　　　　特点：存储关系型数据，查询速度快（二分法），无序（3.5版本以前）

　　　　增：

dic = {'age': 18, 'name': 'bill', 'sex': 'male'}

dic['high'] = 175   # 没有键值对，则添加
dic['age'] = 16   # 如果有键，则值覆盖
print(dic)

dic.setdefault('weight')  # 有键值对，不做任何改变，没有才添加。
dic.setdefault('weight',150)
dic.setdefault('name','william')
print(dic)

　　　　删：

dic = {'age': 18, 'name': 'bill', 'sex': 'male'}

print(dic.pop('age'))   # 按键去删除键值对，返回对应的值
print(dic.pop('high', '没有此键'))   # 可设置默认返回值 无键就返回此值
print(dic)

print(dic.popitem())  # V3.6默认删除最后一个键值对 返回键值对元祖
print(dic)

del dic['name']  # 按照键删除 没有键会报错 无返回值
print(dic)

dic_ = dic.clear()  # 清空字典  返回None
print(dic, dic_)   # {}  None

del dic  #  完全删除字典  无返回值

　　　　改：

dic = {"name":"bill", "age":18, "sex":"male"}
dic["name"] = "william"
print(dic)

dic1 = {"name":"bill", "weight":65}
dic1.update(dic)   # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic1中
print(dic)
print(dic1)

　　　　查：

dic = {'age': 18, 'name': 'bill', 'sex': 'male'}
print(dic.keys())  # 返回列表，元素是键
print(dic.values())  # 返回列表，元素是值
print(dic.items())  # 返回列表，元素是键值对元祖

for i in dic.keys():  # 遍历字典键
    print(i)
for i in dic.values():  # 遍历字典值
    print(i)
for i in dic:  # 默认遍历字典键
    print(i)
for k,v in dic.items():  # 遍历字典键值对
    print(k,v)

print(dic['name'])  # 没有键 会报错

print(dic.get('name1','没有这个键'))  # 没有键 返回设定值 默认是 None

# 并列声明变量

a,b = 1,2
print(a,b)  # 1 2

a = 1
b = 2
a,b = b,a
print(a,b)  # 2 1

a,b = [1,2],[2,3]
print(a,b)  # [1,2] [2,3]

a,b = (1,2)
print(a,b)  # 1 2

a,b = [1,2]
print(a,b)  # 1 2

　　　　字典嵌套：

dic = {
    'name':['bill','william','shaw'],
    'py':{
        'time':'1314',
        'money':1980,
        'addr':'CBD',
    },
    'age':21
}
dic['age'] = 56
dic['name'].append('ritian')
dic['name'][1] = dic['name'][1].upper()
dic['py']['sex'] = 'male'
print(dic)

　　7、集合set：不常用

　　　　set -- {  ，，}

　　　　无序、不重复的数据集合，里面的元素是不可变类型（可哈希）

　　　　集合本身是可改变类型（不可哈希），所以集合做不了字典的键

　　　　去重 -- 把一个列表变成集合，就自动去重了

　　　　关系测试 -- 测试两组数据之前的交集、差集、并集等关系。

　　　　创建：

set1 = set({1,2,3})
set2 = {'bill', 'william', 1, True, (1,2)}
print(set1)
print(set2)

　　　　增：

# add
set1.add('女神')
print(set1)
# update
set2.update('abc')
print(set2)

　　　　删：

print(set1.pop())  # 随机删除，有返回值
print(set1)

set1.remove('bill')  # 按元素删除，无元素报错
print(set1)

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

del set1  # 删除集合

　　　　查：

for i in set1:
    print(i)

　　　　去重：

li = [1,2,33,33,2,1,4,5,6,6]
set1 = set(li)
li = list(set1)
print(li)

　　　　其他操作：交、并、差、反交、子、超

　　　　　　交集（ &  、 intersection）：

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
set3 = set1 & set2
print(set3)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

　　　　　　并集（  |  、 union）：

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7}

　　　　　　差集（ - 、difference）:

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set2.difference(set1))  # {6, 7, 8}

　　　　　　反交集（ ^ 、symmetric_difference）:

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

　　　　　　子集与超集（< issubset  、> issuperset）：

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))  # 这两个相同，都是说明set2是set1超集。

　　　　不可变集合（frozenset），只能查：

set1 = frozenset('barry')
print(set1,type(set1))
for i in set1:
    print(i)

　　8、数据类型总结

 　　　　按存储空间的占用分（从低到高）：

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

　　　　按存值个数区分：

原子类型 -- 数字、字符串、布尔值
容器类型 -- 列表、元祖、字典、集合

　　　　按可变不可变区分：

可变  --  列表、字典
不可变 -- 数字、字符串、布尔值、元祖

　　　　按访问顺序区分：

直接访问 -- 数字
顺序访问（序列）-- 字符串、列表、元祖
键值访问（映射）-- 字典

　　9、其他（for，enumerate，range）

　　　　for循环：按照顺序循环可迭代对象

# 遍历字符串
msg = 'william-shaw'
for s in msg:
    print(item)

# 遍历列表
li = ['bill','比尔','男神','云鹤']
for i in li:
    print(i)

# 遍历字典
dic = {'name':'william','age':18,'sex':'m'}
for k,v in dic.items():
    print(k,v)

# 循环嵌套
li = [1,2,3,5,'bill',[2,3,4,5,'william'],'shaw']
for i in li:
　　if type(i) == list:
　　　　for k in i:
　　　　　　print(k)
　　else:
　　　　print(i)

　　　　range：指定范围，生成指定数字（顾头不顾尾）

for i in range(3,10): # 3 - 9
    print(i)
for i in range(10):  # 默认 从0开始
    print(i)
for i in range(0,10,3):  # 步长3
    print(i)
for i in range(10,0,-2):  # 反向步长  不含 0
    print(i)
for i in range(10,-1,-2):  # 反向步长 包含 0
    print(i)
for i in range(0,10，-1):  # 不报错，返回空
    print(i)

　　　　enumerate：枚举

　　　　　　将可迭代对象组成一个索引序列，利用它可以同时获得索引和值

li = ['bill','billy','william','will','shaw']
for i in enumerate(li):  #  索引和元素的元祖
    print(i)
for index,name in enumerate(li,1):  # 起始位置默认是0，可更改
    print(index, name)

三、深浅copy

　　1,  赋值运算

　　　　对于赋值运算来说，l1与l2指向的是同一个内存地址，完全一样。

l1 = [1,2,3,['bill','billy']]
l2 = l1

l1[0] = 111
print(l1)  # [111, 2, 3, ['bill','billy']]
print(l2)  # [111, 2, 3, ['bill','billy']]

l1[3][0] = 'william'
print(l1)  # [111, 2, 3,  ['william','billy']]
print(l2)  # [111, 2, 3,  ['william','billy']]

　　

　　2，浅拷贝--copy

　　　　对于浅copy来说，第一层创建的是新的内存地址；

　　　　而从第二层开始，指向的都是同一个内存地址。

l1 = [1,2,3,['bill','billy']]

l2 = l1.copy()
print(l1,id(l1))  # [1, 2, 3, ['bill','billy']] 2380296895816
print(l2,id(l2))  # [1, 2, 3, ['bill','billy']] 2380296895048
l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['bill','billy']] 2593038941128
print(l2,id(l2))  # [1, 2, 3, ['bill','billy']] 2593038941896
 
l1[3][0] = 'william'
print(l1,id(l1[3]))  # [1, 2, 3, ['william','billy']] 1732315659016
print(l2,id(l2[3]))  # [1, 2, 3, ['william','billy']] 1732315659016

# l2 = l1[:]  与  l2 = l1.copy（） 一样

　　3，深拷贝--deepcopy

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

import copy
l1 = [1,2,3,['bill','billy']]
l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, ['bill','billy']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['bill','billy']] 2915377167048

l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['bill','billy']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['bill','billy']] 2915377167048

l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 222, 3, ['william','billy']] 2915377167240
print(l2,id(l2[3]))  # [1, 2, 3, ['bill','billy']] 2915377167304

案例练习：

　　1、元素分类：

'''
有一列表，li= [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66的所有值列表, 'k2': 小于66的所有值列表}
'''

li= [11,22,33,44,55,66,77,88,99,90]
dic ={}
li_greater=[]   #大于66的所有值列表
li_less=[]        #小于66的所有值列表
for i in li:
    if i == 66:
        pass
    elif i > 66 :
        li_greater.append(i)
    else:
        li_less.append(i)
dic.setdefault('k1', li_greater)
dic.setdefault('k2', li_less)
print(dic)

　　2、购物车输出：

'''
输出商品列表, li = ["手机", "电脑", '鼠标垫', '游艇']，用户输入序号，添加用户选中的商品
要求：1：页面显示 序号 + 商品名称，如：
        1 手机
        2 电脑
        …
     2：用户输入选择的商品序号，打印商品名称，并添加购物车
     3：如果用户输入的商品序号有误，则提示输入有误，并重新输入。
     4：用户输入Q或者q，退出程序。
'''

li = ["手机", "电脑", "鼠标垫", "游艇"]
cart = []
flag = True
while flag:
    for i in li:
        print('{}	{}'.format(li.index(i)+1,i))
    choice = input('请输入选择的商品序号/输入Q或者q退出程序：')
    if choice.isdigit():
        choice = int(choice)
        if 0 < choice <= len(li):
            cart.append(li[choice-1])
            print(li[choice-1],'已加入购物车!')
        else:
            print('请输入有效数字!')
    elif choice.upper() == 'Q':
        flag = False
    else:
        print('请输入数字!')  
else:
    print('已退出！')
    if cart != []:
        print('购物车列表为：' )
        print(cart)