day02--Python基础二（基础数据类型）

一、数据与数据类型

　　1 什么是数据？

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

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

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

　　3 数据类型

　　　数字（int）

　　　字符串 （str）

　　　列表 （list）

　　　元组 （tuple）

　　　字典 (dict)

　　　集合 (set)

二、基础数据类型

　　2.1数字 int

　　数字主要是用于计算用的，使用方法并不是很多，就记住一种就可以：

　　

#bit_length() 当十进制用二进制表示时，最少使用的位数
a = 3
b = 5
print(a.bit_length())
print(b.bit_length())

结果如何下：
2
3

Process finished with exit code 0

换算如下：
二进制          十进制
0000 0001          1
0000 0010          2
0000 0011          3

　　2.2 布尔值 bool

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

真  <==> 1 <==> True

　　假  <==> 0 <==> False

　　int --> str: str(int)

　　str --> int: int(str)  #str必须全部是数字组成。

　　int --> bool : 0 =False   非零=True

　　bool --> int : int(True)=1  int(False)=0

　　str  --> bool : ''(空) =False  非空字符串=True

　　2.3 字符串 str

　　2.3.1 字符串的所以与切片

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

a = 'ABCDKDSEKD'
print(a[0])
print(a[2])
print(a[-1])
print(a[-2])

结果为：
A
C
D
K

Process finished with exit code 0

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

a = 'ABCDKDSEKD'
print(a[0:3])
print(a[2:5])
print(a[0:])　　#默认到最后
print(a[0:-1])　　#-1就是最后一个
print(a[-1::-1])　　#倒序，必须加反向步长
print(a[0:5:2])　　#加步长　
print(a[5:0:-2])　　#反向加步长

结果为：
ABC
CDK
ABCDKDSEKD
ABCDKDSEK
DKESDKDCBA
ACK
DDB

Process finished with exit code 0

　　2.3.2 字符串的常用方法

s = 'qingSHANGlys' #定义一个字符串 s

（1）# * capitalize 首字母大写，其他字母小写
print(s.capitalize())
结果为：
Qingshanglys

（2）# *** 全部大写upper() 全部小写lower()
print(s.upper())
print(s.lower())
结果为：
QINGSHANGLYS
qingshanglys

#注 upper 和lower可以实现验证码功能，如下：
code = 'QeAr'.upper()
your_code = input('请输入验证码：').upper()
if your_code == code:
    print('验证成功')
else:
    print('验证失败')

(3)#* 大小写反转 swapcase()
print(s.swapcase())
结果为：
QINGshangLYS

（4）#*非字母的元素隔开的每个单词首字母大写 title()
s = 'alex wusir*oldboy3taibia'
print(s.title())
结果为：
Alex Wusir*Oldboy3Taibia

（5）# center 居中，长度自己设定，可自定义填充物，默认填充物None
print(s.center(30))
print(s.center(30,'*'))
结果为：
     alex wusir*oldboy3taibia
***alex wusir*oldboy3taibia***

（6）# *** startswith 判断是否以...开头 可切片
　　 # *** endswith判断是否以...结尾   可切片

s = 'qingSHANGlys'

print(s.startswith('qi',0,2))
print(s.startswith('Q'))
print(s.endswith('s'))
print(s.endswith('S'))
结果为：
True
False
True
False

(7)# *** strip 去除首尾的空格，制表符\t,换行符。不仅仅是去除空格....(lstrip()只去除左边、 rstrip()只去除右边)
s = '  tyoyldBoyrtet  '

print(s)
s1 = s.strip()
print(s1)
print(s1.strip('t')) #去除首尾的‘t’
结果为：
  tyoyldBoyrtet  
tyoyldBoyrtet
yoyldBoyrte

(8)*** split  (str ---> list) 以什么分割，最终形成一个列表此列表不含有这个分割的元素。

s='liuyisai,lys,qingshan'
print(s.split(','))
print(s.split('s'))
print(s.split('s',2))　　#指定分隔符服个数

结果为：
['liuyisai', 'lys', 'qingshan']
['liuyi', 'ai,ly', ',qing', 'han']
['liuyi', 'ai,ly', ',qingshan']

(9)#join 将list --->str

s1 = 'lys'
print('+'.join(s1))
s2 = ['lys','qingshan','liuyisai']
print('+'.join(s2))
结果为：
l+y+s
lys+qingshan+liuyisai

(10)#replace 替换

s1='lys say you beautiful'
s2 = s1.replace('lys','qingshan')
print(s2)
结果为：
qingshan say you beautiful

(11)#find 通过元素找索引  找不到返回-1
　　# index 通过元素找索引 找不到报错

s = 'qingshanlys'
print(s.find('s'))　　#4
print(s.find('lys'))　　#8
print(s.find('b'))　　#-1
print(s.index('y'))　　#9
print(s.index('b'))　　#报错

(12)#格式化输出format

res = '我叫{},今年{}岁，爱好{}'　　
print(res)　　#我叫{},今年{}岁，爱好{}
res='我叫{0}今年{1}岁，爱好{2},我依然叫{0}'.format('lys',25,'girl')
print(res)　　#我叫lys今年25岁，爱好girl,我依然叫lys
res='我叫{name}今年{age}岁，爱好{hobby}'.format(hobby='gril', name='lys', age=25)
print(res)　　#我叫lys今年25岁，爱好gril

(13)#公共方法：len 长度
　　　　　　　　count　　数量

s = 'fdsafasdfasdfsadf'

print(len(s))　　#17
print(s.count('a')) #4

#####is系列

s = 'lys123'
print(s.isdigit())　　#False　　#字符串只由数字组成
print(s.isalpha())　　#False　　#字符串只由字母组成
print(s.isalnum())　　#Ture　　#字符串由字母或数字组成

s = input('请输入数字：').strip() #删除前后空格
if s.isdigit():　　#判断是否为数字
    print('OK')
else:
    print('erre')

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

　　li = [‘lys’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’lys’}]

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

li = ['lys',25,'boy','shandong']
print(li[0])    #lys
print(li[-1])    #shandong    -1代表最后一个元素的索引
print(li[:2])   #['lys', 25]     切片
print(li[:3:2])    #['lys', 'boy']    加步长

　　

　　2.4.1 list 赠

li = ['lys',25,'boy','shandong']

#append 在最后追加
li.append('girl')
li.append([1,2,3])
print(li)
结果为：
['lys', 25, 'boy', 'shandong', 'girl', [1, 2, 3]]

#insert 按照索引插入到指定位置
li.insert(0,'girl')
li.insert(2,[1,2,3])
print(li)
结果为：
['girl', 'lys', [1, 2, 3], 25, 'boy', 'shandong']

#extend 迭代着添加
li.extend('girl')
li.extend(['',222,333])
print(li)
结果为['lys', 25, 'boy', 'shandong', 'g', 'i', 'r', 'l', '', 222, 333]

　　

　　2.4.2 list 删

li = ['lys',25,'boy','shandong']
(1)#pop 有返回值  按照索引删除
print(li.pop(2))
print(li)
结果为：
boy
['lys', 25, 'shandong']

(2)#remove 按照元素去删，没有返回值
print(li.remove('lys'))
print(li)
结果为：
None
[25, 'boy', 'shandong']

(3)#clear 清空列表
li.clear()
print(li)
结果为：
[]

(4)#del 内存级别删除列表，支持切片
del li
print(li)

#按索引删除
del li[-1]
print(li)
结果为：
['lys', 25, 'boy']

#切片删除
del li[:2]
print(li)
结果为：
['boy', 'shandong']

　　2.4.3 list 改

li = ['lys',25,'boy','shandong']

#按照索引改
print(li[2])    #boy
li[2] = 'girl'
print(li)    #['lys', 25, 'girl', 'shandong']

#按照切片去改
li[:2] = 'abc'
print(li)
结果为：
['a', 'b', 'c', 'boy', 'shandong']
li[1:3] = [111,222,333,444]
print(li)
结果为：
['lys', 111, 222, 333, 444, 'shandong']

　　2.4.4 list 查

li = ['lys',25,'boy','shandong']

#按照索引去查询
print(li[0])   #lys 

#按照切片去查询
print(li[1:3])    #[25, 'boy']

#循环查询
for i in li:
    print(i)

　　2.4.5 list 其他操作

li = [1,2,3,1,2,2,2,3,1]

(1)#count 统计某个元素在列表中出现的次数
print(li.count(2))    #

(2)#len 统计元素总个数
print(len(li))    #

(3)sort 用于在原位置对列表进行排序
l2 = [3,2,4,6,9,8,7,1]
l2.sort()    #默认从小到大排序
print(l2)    #[1, 2, 3, 4, 6, 7, 8, 9]

l2.sort(reverse=True)    #从大到小排序
print(l2)    #[9, 8, 7, 6, 4, 3, 2, 1]

(4)#reverse 将列表中的元素反向存放
l2.reverse()
print(l2)    #[1, 7, 8, 9, 6, 4, 2, 3]

(5)#index 用于从列表中找出某个值第一个匹配项的索引位置
print(li.index(2))    #

2.5 字典dict

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

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

　　key:不可变的数据类型(可哈希)：str，bool，tuple，int。
   　　　value：任意数据类型。
     　　　　 数据类型分类：
          　　　　不可变的数据类型(可哈希)：str，bool，tuple，int
          　　　　可变的数据类型：dict，list，set。           　　　　容器类数据类型：list，tuple，dict，set.
　　　  字典：存储数据多，关系型数据，查询速度快（二分查找）。
　　　  3.6版本之前，字典是无序的，3.6之后字典是有序的。

　　2.5.1 字典dict 赠

dic = {'name':'lys','age':25,'hobby':'girl'}

(1)dic['high'] = 178    #有则覆盖，无则添加
print(dic)    #{'name': 'lys', 'age': 25, 'hobby': 'girl', 'high': 178}
dic['name'] = '青衫'
print(dic)    #{'name': '青衫', 'age': 25, 'hobby': 'girl'}

(2)#setdefault() 有则不变，无则添加
dic.setdefault('high',178)
print(dic)    #{'name': 'lys', 'age': 25, 'hobby': 'girl', 'high': 178}
dic.setdefault('name','青衫')
print(dic)    #{'name': 'lys', 'age': 25, 'hobby': 'girl'}

　　2.5.2 字典dict 删

dic = {'name':'lys','age':25,'hobby':'girl'}

(1)#pop('key') 删除指定的健，有返回值、返回对应的值
print(dic.pop('hobby'))    #girl
print(dic)    #{'name': 'lys', 'age': 25}

(2)#clear()   清空
dic.clear()
print(dic)    #{}

(3)#popitem() 随机删除，返回值{3.6及以后版本删除最后一个值，不再随机}
print(dic.popitem())    #('hobby', 'girl')
print(dic)    #{'name': 'lys', 'age': 25}

(4)#del 内存级别删除
del dic['age']
print(dic)    #{'name': 'lys', 'hobby': 'girl'}
del dic
print(dic)    #已找不到该字典

　　2.5.3 字典dict 改

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic.update(dic2) #update() 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中

结果为：{'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}

　　2.5.4 字典dict 查

dic = {'name':'lys','age':25,'hobby':'girl'}

print(dic['name'])     #lys
print(dic['name1'])    #报错    so: 没有会报错
print(dic.get('hobby'))    #girl
print(dic.get('hobby1'))    #None
print(dic.get('hobby1','没有此值'))    #没有此值    so:查不到返回指定的值，默认为None

　　2.5.5 字典dict的其他操作

dic = {'name':'lys','age':25,'hobby':'girl'}

(1)#items()
item = dic.items()
print(item,type(item))
结果为：
dict_items([('name', 'lys'), ('age', 25), ('hobby', 'girl')]) <class 'dict_items'>    #这个类型就是dict_items类型，可迭代的

for i in dic:
    print(i)
结果为：#循环取出dic 所以的key
name
age
hobby

for i in dic.items():
    print(i)
结果为：
('name', 'lys')
('age', 25)
('hobby', 'girl')

for k,v in dic.items():
    print(k,v)

结果为：
name lys
age 25
hobby girl

(2)keys()
for i in dic.keys():
    print(i)
结果为：    #循环取出字典dic的所以key
name
age
hobby

(3)values()
for i in dic.values():
    print(i)
j结果为：循环取出字典dic的所以value
lys
25
girl

　　2.6 元组 tulpe

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

tu = (11,2,True,[2,3,4],'lys')
for i in tu:
    print(i)
结果为：
11
2
True
[2, 3, 4]
lys

print(tu[2])    #True

print(tu.index('lys'))    #

tu[-2].append(666)　　#子不可变，孙看变
print(tu)    #(11, 2, True, [2, 3, 4, 666], 'lys')

　　2.7 集合 set

　　集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：

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

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

　　2.7.1 集合的创建

set1 = {1,2,3,4}
set2 = {'a','b','c'}
print(set1,set2)

结果为：
{1, 2, 3, 4} {'a', 'c', 'b'}

　　2.7.2 集合的赠

set1 = {'lys','qingshan','liuyisai','liu'}

set1.add(666)    #位置随机
print(set1)    #{'liuyisai', 'lys', 'liu', 666, 'qingshan'}

set1.update('abc')    #迭代着增加
print(set1)    #{'liuyisai', 'lys', 'liu', 'c', 'a', 'b', 666, 'qingshan'}

set1.update(['a1','b2','c3'])
print(set1)    #{'lys', 'liuyisai', 'c3', 'b2', 'liu', 'a1', 'qingshan'}

　　2.7.3 集合的删

set1 = {'lys','qingshan','liuyisai','liu'}

set1.remove('liuyisai')    #删除一个指定元素
print(set1)    #{'liu', 'lys', 'qingshan'}

set1.pop()    #随机删除一个元素
print(set1)

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

del set1    #删除集合
print(set1)

　　2.7.4 集合的去重功能

list = ['a','b','a',1,1,1,2]
print(set(list))    #{1, 2, 'b', 'a'}

　　2.7.5 集合的交集（&  或者 intersection）

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

print(set1 & set2)    #{4, 5}

　　2.7.6 集合的并集 （| 或者 union）

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

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

　　2.7.7 集合的差集 （- 或者 difference）

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

print(set1 - set2)    #{1, 2, 3}

　　2.7.8 集合的反交集

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

print(set1 ^ set2)
结果为：
{1, 2, 3, 6, 7, 8}

　2.7.9 集合子集与超集

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超集。

　　2.7.10 frozenset 不可变集合，让集合变成不可变类型。

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

三、其他（enumerate，range，以及分别赋值等）

　　enumerate :枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li =['lys','qingshan','linux','python','DB']

for i in enumerate(li):
    print(i)
结果为：
(1, 'qingshan')
(2, 'linux')
(3, 'python')
(4, 'DB')

for index,name in enumerate(li):
    print(index,name)
结果为：
0 lys
1 qingshan
2 linux
3 python
4 DB

for index,name in enumerate(li,5):    #默认从0开始，可以指定起始位置
    print(index,name)
结果为：
5 lys
6 qingshan
7 linux
8 python
9 DB

　　range：指定范围，生成指定数字，配合for循环使用，不能直接print

for i in range(10):    #默认从0开始，顾头不顾尾
    print(i)
结果为：
0
1
2
3
4
5
6
7
8
9

for i in range(5,10): #指定起始位置 顾头不顾尾
    print(i)
结果为：
5
6
7
8
9

for i in range(5,10,2):    #支持步长
    print(i)
结果为：
5
7
9

for i in range(5,1,-1):    #反向打印
    print(i)
结果为：
5
4
3
2

　　fromkeys

dic1 = dict.fromkeys('abc','张三')
print(dic1)
dic2= dict.fromkeys([1,2,3],'李四')
print(dic2)

结果为：
{'a': '张三', 'b': '张三', 'c': '张三'}
{1: '李四', 2: '李四', 3: '李四'}

dic3 = dict.fromkeys('abc',[])
# print(dic3)
dic3['a'].append('老男孩')
print(dic3)

结果为：
{'a': ['老男孩'], 'b': ['老男孩'], 'c': ['老男孩']}

四、数据类型补充

l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']

del l1[1::2]
print(l1)

for i in range(len(l1)):
    print(l1)  # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
                # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
                # ['alex', 'taibai', 'barry', '老男孩']
                 # ['alex', 'taibai', 'barry', '老男孩']
    print(i) # 0 1  2  3
    if i % 2 == 1:
        del l1[i]
    print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
             # ['alex', 'taibai', 'barry', '老男孩']
            # ['alex', 'taibai', 'barry']
    print(i) # 0 1
#再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错

#dict 再循环字典时，不要改变字典的大小。
dic = {'k1':'v1','k2':'v2','k3':'v3','r':666}
l1 = []
for i in dic:
    if 'k' in i:
        l1.append(i)
# print(l1)

for i in l1:
    del dic[i]
print(dic)

#tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。
tu1 = (1)
print(tu1,type(tu1))
tu2 = ('alex')
print(tu2,type(tu2))

tu3 = (['alex',1,2])
print(tu3,type(tu3))

五、深浅copy

　　1 先看赋值运算。

l1 = [1,2,3,['barry','alex']]
l2 = l1
l1[0] = 5
l1[3][1] = 'lys'
print(l1)    #[5, 2, 3, ['barry', 'lys']] 34404952
print(l2)    #[5, 2, 3, ['barry', 'lys']] 34404952

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

　　2、浅拷贝copy。

l1 = [1,2,3,['barry','alex']]
l2 = l1.copy()
l1[3][1] = 'lys'
l1[0] = 5
print(l1,id(l1))    #[5, 2, 3, ['barry', 'lys']] 6617688
print(l2,id(l2))    #[1, 2, 3, ['barry', 'lys']] 6617768
print(id(l1[3]))    #
print(id(l2[3]))    #

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

　　3、深拷贝deepcopy。

import copy
l1 = [1,2,3,['barry','alex']]
l2 = copy.deepcopy(l1)
l1[3][1] = 'lys'
l1[0] = 5
print(l1)    #[5, 2, 3, ['barry', 'lys']]
print(l2)    #[1, 2, 3, ['barry', 'alex']]

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