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

一、引子：

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

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

2、数据类型：

　　数字

　　字符串

　　列表

　　元组

　　字典

　　集合

　　布尔

二、整体介绍：

1 、int  数字：1,2,3... 用于计算、运算

2、str  字符串： '老男孩'...   主要是少量的数据的存储

3、bool  布尔：True和False，主要用于判断真假。

4、list 列表：[true，1，‘alex’，{‘name’：'oldboy'},[1,2,3],(2,3,4),{'wusir'}]  列表，js里面叫数组

储存大量的数据，可以放多种数据类型，所以它也叫容器类数据。例如：布尔、数字、字符串、字典、列表、元祖、集合...

5、tuple：元组，也可以放多种数据类型，只读列表，不能进行修改，只限制儿子级别的，元组里面的字典可以改。

比如一些重要文件、信息储存在元组中，只允许别人看，不能被恶意修改。

（true，1，‘alex’，{‘name’：'oldboy'},[1,2,3],(2,3,4),{'wusir'}）

6、dict 字典：可以储存大量的数据，关联型数据。而且字典的查询速度特别快，因为它符合二分查找。

{'name':'oldboy','age':45}

7、set  集合：用户关系型数据的交集、并集、差集、子集...  ，可以用于列表的去重。集合中元素都是不重复的。

8、

 

三、基础数据类型详细介绍

1、int（bit_length()方法，该方法也不常用）

i.bit_length()表示将十进制转换成二进制，所占的最少有效位数

"""
二进制          十进制
0000 0001          1
0000 0010          2
0000 0011          3
0000 0100          4
"""

i=3
print(i.bit_length())
i=4
print(i.bit_length())

执行结果：

2
3

2、bool 布尔值

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

真   1   True。

假   0   False。    

int转换成布尔：
int --- > bool 0 为False 非零 为True

print(bool(0))  值为：False

print(bool(1))  值为：True

布尔值转换成数字：
bool ---> int int(True) 等于1 int(False) 等于 0
print(int(True)) 值为：1

print(int(False))值为：0

str转换成布尔：空字符串是False，非空是true
str ---> bool '' False 非空字符串 True
print(bool('')) 值为False，有空格的不叫False

 3、字符串（字符串是有索引的，索引就是它的下标。索引从后往前最后一个是-1）

s = 'python自动化运维21期'
s1 = s[0]   #通过索引找到对应的元素
print(s1)

3.1、字符串的索引和切片（切片、步长）
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

s = 'python自动化运维21期'
print(s[6:9])   #自动化

print(s[-1])    #-1

print(s[-2])    #-2

切片：（顾头不顾腚）
s[起始索引：结束索引+1：步长]

print(s[:6])    #python

print(s[:6:2])  #从p开始python间隔一个输出一个pto

print(s[:])     #输出整个字符串  python自动化运维21期

print(s[-1:-6:-1])  #期12维运  注意：倒着取值，必须加反向步长

print(s[8:1:-1])   #化动自noht 注意：倒着取值，必须加反向步长

print(s[-1:-5:-2])  #期2

3.2、字符串常用方法：

* s.capitalize()  首字母大写，其他字母小写

s='oldBOY'
s1=s.capitalize()
print(s1)   #Oldboy

*** s.upper()   全部转大写

s2=s.upper()
print(s2)    #OLDBOY

*** s.lower()  全部转小写

s3=s.lower()
print(s3)   #oldboy

*** s.swapcase()   大小写反转

s4=s.swapcase()
print(s4)   #OLDboy

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

s='alex wusir*oldboy3taibai'
s5=s.title()
print(s5)    #Alex Wusir*Oldboy3Taibai

* s.center()  居中，长度自己设定，默认填充物是None，填充物就是括号里面的

s='oldboy'
s6=s.center(30)
print(s6)   #            oldboy            

s='oldboy'
s6=s.center(30,'*')
print(s6)  #************oldboy************


* s.count  字符串中某个元素的个数

s='olodboy'
s7=s.count('o',0,5)  #切片，顾头不顾尾
print(s7)    # 2

*** s.startswith()   s.endswith()   start...end...切片，切片都是顾头不顾尾

s='olodboy'
s8=s.startswith('o')
print(s8)    #True

s='olodboy'
s8=s.startswith('O')
print(s8)    #False

s9=s.endswith('y')
print(s9)     #True

s10=s.startswith('ol')
print(s10)   #True

s11=s.startswith('lo',1,5)     #切片都是顾头不顾尾
print(s11)     #True

*** s.strip()       #去除首尾的空格、制表符\t、换行符\n

s='\t自动化测试\n'    （\t是制表符，代表4个空格。\n是换行符）
print(s)       #    自动化测试

s.strip()    #不仅仅能去除空格，还可以使用填充物，举例
s='oldboey'

s12=s.strip('oye')   #只有首尾包含oye元素就去掉，o,y,e是单独的，没有顺序的，去跟字符串首尾地方去

print(s12)      #ldb

name=input('>>>').strip()       #以后input要加strip()，为了项目

s='    oldboey    '
s13=s.lstrip()   #只去除左边空格   
s14=s.rstrip()   #只去除右边空格
print(s13)       #oldboey  
print(s14)      #    oldboey

***  split（str--->list相当于字符串转换成列表，可以设置切割次数，隔开后的数比你设置的元素多1）

s = 'oldboywusiroalex'
l = s.split()
print(l)      #['oldboywusiroalex']

s1 = 'oldboy,wusir,alex'
l = s1.split(',')
print(l)     #['oldboy', 'wusir', 'alex']

s = 'oldboywusiroalex'
l2 = s.split('o')   
print(l2)    #['', 'ldb', 'ywusir', 'alex']

s = 'oldboywusiroalex'
s15=s.split('o',1)     #设置了切割次数
print(s15)   #['', 'ldboywusiroalex']

***  join  (list---->str)将list转换成字符串

s='olodboy'
s16='+'.join(s)
print(s16)    #o+l+o+d+b+o+y

s=['alex','wusir','taibai']
s17='_'.join(s)
print(s17)    #alex_wusir_taibai

*** replace   替换

s='abcd'
s1=s.replace('a','p')
print (s1)    #pbcd


*** find & index      find通过元素找索引，找不到返回-1；index通过元素找索引，找不到会报错。（比较下用find比较好）

s='abcd'
s1=s.find('d')
s2=s.index('c')
print(s1)     #3
print(s2)     #2

s='abcd'
s1=s.find('m')
print(s1)    #-1

s='abcd'
s1=s.index('m')
print(s1)
报错：

Traceback (most recent call last):
File "H:/MyProject/day02.py", line 220, in <module>
s1=s.index('m')
ValueError: substring not found

***  格式化输出format(3种用法)  

{}相当于%，{}中间不能有空格

   第1种：

res='我今年{}岁，我的名字叫{}'.format(18,'alex')
print(res)    #我今年18岁，我的名字叫alex
第2种：

res='我今年{0}岁，我的名字叫{1},爱好{2},我依然叫{1}'.format(18,'alex','旅游')
print(res)    #我今年18岁，我的名字叫alex,爱好旅游,我依然叫alex

第3种：

res='{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res)   #egon 18 male

res='我养了只小宠物{str},它的名字叫{name},今年{age}岁，每天早上都{do}'.format(name='super',age=18,do='唱歌',str='猪')

print(res)  #我养了只小宠物猪,它的名字叫super,今年18岁，每天早上都唱歌


###公共方法：列表、元祖、字符串都可以用的方法。len、count

s = 'fdsafsdagsdafjdskahdhjlsadhfkj'
print(len(s))      #30
s = 'fdsadd'
print(s.count('d'))  #3


* is系列：isalnum、isalpha、isdigit

name = 'jinxin123'
print(name.isalnum()) #字符串由字母或数字组成    #True
print(name.isalpha()) #字符串只由字母组成       #False
print(name.isdigit()) #字符串只由数字组成       #False
i = '123a'
if i.isdigit():
    i = int(i)
else:
    print("输入有误...")             #输入有误...

name = '123'
print(name.isalnum())
print(name.isdigit())
print(name.isalpha())

结果为：

True
True
False

 

 

#!/usr/bin/env python
# -*-coding:utf-8-*-

#求12356的所有子集
s='12356'
def PowerSetsBinary(items):
    #generate all combination of N items
    N = len(items)
    #enumerate the 2**N possible combinations
    for i in range(2**N):
        combo = []
        for j in range(N):
            #test jth bit of integer i
            if(i >> j ) % 2 == 1:
                combo.append(items[j])
        yield combo
listson=[]
for i in PowerSetsBinary(s):
    listson.append(i)


end_listson=[]
# test=[]
for j in listson:
    new_str=','.join(j)
    # test.append(new_str)
    if new_str != '':
        end_listson.append(new_str)

print(len(end_listson),end_listson)
# print(len(test))

 执行结果：

(31, ['1', '2', '1,2', '3', '1,3', '2,3', '1,2,3', '5', '1,5', '2,5', '1,2,5', '3,5', '1,3,5', '2,3,5', '1,2,3,5', '6', '1,6', '2,6', '1,2,6', '3,6', '1,3,6', '2,3,6', '1,2,3,6', '5,6', '1,5,6', '2,5,6', '1,2,5,6', '3,5,6', '1,3,5,6', '2,3,5,6', '1,2,3,5,6'])

 4、列表（增（3种 ：append、insert、extend）、删（pop、remove、clear、del）、查、改）

总结：在循环一个列表中，不要对列表进行删除的动作（改变列表元素的个数的动作），会出错。

列表也支持索引查找、切片、步长

li = [111,'alex',222,'wusir']
print(li[1])  # alex
print(li[-1])  # wusir
print(li[:2])  # [111, 'alex']
print(li[:3:2])

值为：

alex
wusir
[111, 'alex']
[111, 222]

##增 append

l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
#增
#append 在最后追加
l.append('葫芦')
l.append([1,2,3])
print(l)      #['老男孩', 'alex', 'wusir', 'taibai', 'ritian', '葫芦', [1, 2, 3]]

print(l.append('好'))   #None    这个是完成追加的动作


## insert插入

l.insert(1,'景nvshen')    #按索引位置插入
print(l)             #['老男孩', '景nvshen', 'alex', 'wusir', 'taibai', 'ritian']

#迭代着添加  extend
l.extend('alex')
l.extend(['111',222,333])
print(l)     #['老男孩', 'alex', 'wusir', 'taibai', 'ritian', 'a', 'l', 'e', 'x', '111', 222, 333]

--------------------------------------------------------------------------------------
#删除

#pop 有返回值  按照索引删除，有返回值，删除谁返回谁，增删查改种唯一一个有返回值的
print(l.pop(0))     #老男孩
print(l)            #['alex', 'wusir', 'taibai', 'ritian']

#remove     按元素删除
l.remove('alex')
print(l)       #['老男孩', 'wusir', 'taibai', 'ritian']

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

#del 内存级别删除列表
del l
print(l)    #报错

#del按索引删除
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
del l[1]
print(l)    #['老男孩', 'wusir', 'taibai', 'ritian']

#del切片删除

l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
del l[:3]
print(l)    #['taibai', 'ritian']

# 改
#按照索引改
print(l[2])     #wusir
l[2] = '武藤兰'
print(l)        #['老男孩', 'alex', '武藤兰', 'taibai', 'ritian']

#按照切片去改  （把切片内删除，把想添加元素最小单位添加进去）
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
l[:2] = 'abc'
print(l)                 #['a', 'b', 'c', 'wusir', 'taibai', 'ritian']
l[1:3] = [111,222,333,444]
print(l)                 #['a', 111, 222, 333, 444, 'wusir', 'taibai', 'ritian']

# 查（3种）
#按照索引去查询，按照切片去查询，for循环查找
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
for i in l:
    print(i)


其他方法：

l1 = [1,2,1,2,1,1,3,4]

# 其他方法：
#count 计数
print(l1.count(1))    #4

#len
print(len(l1))        #8

#通过元素找索引
l1 = [1,2,1,2,1,1,3,4]
print(l1.index(2))    #1  只找第一个出现的位置


#排序

l2 = [3,2,4,6,9,8,7,1]

#sort
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]

#reverse         #反过来输出
l2 = [3,2,4,6,9,8,7,1]
l2.reverse()  #[1, 7, 8, 9, 6, 4, 2, 3]

#列表的嵌套
l1 = [1, 2, 'alfdsafex', 'wusir',['oldboy', 'ritian', 10], 'taibai']
#1,将'alex'全部变成大写，放回原处。
l1[2] = 'ALEX'
print(l1[2].upper())     #ALEX
l1[2] = l1[2].upper()
print(l1)               #[1, 2, 'ALEX', 'wusir', ['oldboy', 'ritian', 10], 'taibai']

#2.给['oldboy', 'ritian', 99] 追加一个元素‘女神’。 一个方法
l1[-2].append('女财神')
print(l1)             #[1, 2, 'ALEX', 'wusir', ['oldboy', 'ritian', 10, '女财神'], 'taibai']

#3，将'ritian'首字母大写，放回原处。
l1[-2][1] = l1[-2][1].capitalize()
print(l1)            #[1, 2, 'ALEX', 'wusir', ['oldboy', 'Ritian', 10, '女财神'], 'taibai']

#4，将10通过数字相加，或者字符串相加或者等等，变成'100'

l1 = [1, 2, 'alfdsafex', 'wusir',['oldboy', 'ritian', 10], 'taibai']

l1[-2][-1] = str(l1[-2][-1]) + '0'
print(l1)     #[1, 2, 'alfdsafex', 'wusir', ['oldboy', 'ritian', '100'], 'taibai'] 

List=[1,2,2,2,2,3,3,3,4,4,4,4,'abc']
a = {}
for i in List:
  if List.count(i) >= 1:
    a[i] = List.count(i)
print (a)

执行结果：
{1: 1, 2: 4, 3: 3, 4: 4, 'abc': 1}

 

5、字典（在循环字典时，不要对字典进行删除，不要改变字典的大小）

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

#字典的增

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
#增
#  dic['high'] 有则覆盖，无则添加
dic['high'] = 180
dic['name'] = 'ritian'
print(dic)    #{'name': 'ritian', 'age': 21, 'hobby': 'girl', 'high': 180}

# dic.setdefault() 有则不变，无则添加
dic.setdefault('high')
dic.setdefault('high',180)
dic.setdefault('name','日天')
print(dic)    #{'name': 'taibai', 'age': 21, 'hobby': 'girl', 'high': None}

# 删  pop
dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
print(dic.pop('name'))  # 返回值 对应的值    #taibai

dic.pop('name')    字典的删除，通过键删除，删除整个键值对

print(dic.pop('name1','没有此key sb'))     #没有此key sb

#clear清空字典里面的内容

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

print(dic.popitem())  #随机删除，返回值   #('hobby', 'girl')
print(dic)                             #{'name': 'taibai', 'age': 21}

del dic    #内存级别的删除
print(dic)  

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
del dic['age']  #根据键删除
print(dic)      #{'name': 'taibai', 'hobby': 'girl'}

# 改
dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
dic['name'] = '老男孩'
print(dic)      #{'name': '老男孩', 'age': 21, 'hobby': 'girl'}

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic)  # 将dic的键值对覆盖添加到dic2中，dic不变。
print(dic)     #{'name': 'jin', 'age': 18, 'sex': 'male'}
print(dic2)     #{'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}

#查

dic = {"name":"jin","age":18,"sex":"male"}
print(dic['name2'])   #报错
print(dic.get('name'))   #jin
print(dic.get('name1'))   #None
print(dic.get('name1','没有此key，sb'))   #没有此key，sb

#keys() values() items()
dic = {"name":"jin","age":18,"sex":"male"}
print(list(dic.keys()))
for i in dic.keys():
    print(i)

结果如下：

['name', 'age', 'sex']
name
age
sex

 

----------------------------------

print(dic.values())
for i in dic.values():
    print(i)

执行结果：

dict_values(['jin', 18, 'male'])
jin
18
male

----------------------------------

print(list(dic.items()))
for i in dic.items():
    print(i)
执行结果：

[('name', 'jin'), ('age', 18), ('sex', 'male')]
('name', 'jin')
('age', 18)
('sex', 'male')

-----------------------------

#分别赋值
a,b = 1,2
a,b,c = ['alex', 'wusir', 'ritain']
print(a,b,c)
a = 1
b = 5
a,b = b,a
print(a,b)

执行结果：

alex wusir ritain
5 1

 

for i in dic.items():
    print(i)

执行结果：

('name', 'jin')
('age', 18)
('sex', 'male')

 

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

执行结果：

name jin
age 18
sex male

 

dic = {"name":"jin","age":18,"sex":"male"}
print(len(dic))  #3

#fromkeys
dic1 = dict.fromkeys('abc','张三')
dic2= dict.fromkeys([1,2,3],'李四')
print(dic1)   #{'a': '张三', 'b': '张三', 'c': '张三'}
print(dic2)   #{1: '李四', 2: '李四', 3: '李四'}

dic3 = dict.fromkeys('abc',[])
print(dic3)     #{'a': [], 'b': [], 'c': []}
dic3['a'].append('老男孩')
print(dic3)     #{'a': ['老男孩'], 'b': ['老男孩'], 'c': ['老男孩']}

#字典的嵌套

dic = {
    'name_list':['b哥', '张帝', '人帅', 'kitty'],
    '老男孩':{
        'name':'老男孩',
        'age': 46,
        'sex': 'ladyboy',
    },
}
#1,['b哥', '张帝', '人帅', 'kitty']追加一个元素，'骑兵'
dic['name_list'].append('骑兵')
print(dic)
#2，将kitty全部变成大写。
l1 = dic['name_list']
print(l1[-1].upper())
l1[-1] = l1[-1].upper()
print(dic)
dic['name_list'][-1] = dic['name_list'][-1].upper()
print(dic)

#3，将老男孩 改成oldboy。
dic['老男孩']['name'] = 'oldboy'
print(dic)
#，将ladyboy首字母大写。
dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
print(dic)

执行结果为：

{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
骑兵
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': 'oldboy', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': 'oldboy', 'age': 46, 'sex': 'Ladyboy'}}

 

 

>>> dicxx = {'a':'001', 'b':'002'}
>>> list(dicxx.keys())[list(dicxx.values()).index("001")]
'a'

 

6、元祖（只读，不能进行增、删、改，只能进行查）

查使用for循环

tu = (11,2,True,[2,3,4],'alex')
for i in tu:
    print(i)
print(tu[1]) #通过索引
print(tu[:3:2])  #切片
print(tu.index(True))   #通过元素找索引
print(tu.count(2))     #元素出现的个数
print(len(tu))
tu[-2].append(666)
print(tu)

执行结果：

11
2
True
[2, 3, 4]
alex
2
(11, True)
2
1
5
(11, 2, True, [2, 3, 4, 666], 'alex')

 

7、集合

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

set1 = {1,'alex',False,(1,2,3)}
l1 = [1,1,2,2,3,3,4,5,6,6]
l2 = list(set(l1))
print(l2)   #[1, 2, 3, 4, 5, 6]

set1 = {'alex','wusir','ritian','egon','barry'}
#增
set1.add('666')
print(set1)   #{'ritian', 'alex', 'barry', 'wusir', 'egon', '666'}

# update
set1.update('abc')
print(set1)

#删（remove、pop、clear、del）
set1 = {'alex','wusir','ritian','egon','barry'}

set1.remove('alex')  # 删除一个元素
print(set1)

set1.pop()  # 随机删除一个元素
print(set1)  #{'wusir', 'barry', 'egon', 'ritian'}  该值是变化的

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

del set1  # 删除集合
print(set1)

#----集合：关系测试------

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

#交集 &  intersectio
print(set1 & set2)      #{4, 5}
print(set1.intersection(set2))   #{4, 5}

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

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

print(set2 - set1)      #{8, 6, 7}

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

#反交集 ^ symmetric_difference
print(set1 ^ set2)                      #{1, 2, 3, 6, 7, 8}
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)            #True
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。 #True

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

--------------------------------------------
不可变集合，让集合变成不可变类型

s = frozenset('barry')
s1 = frozenset({4,5,6,7,8})
print(s,type(s))
print(s1,type(s1))
执行结果：

frozenset({'a', 'y', 'r', 'b'}) <class 'frozenset'>
frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>

8、数据类型的补充

range：数字的列表范围，可定制的数字列表、顾头不顾尾

l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
#1
del l1[1::2]
print(l1)   #['alex', 'taibai', '老男孩']
-----------------------------------------------------

#再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错

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

----------------------------------------------------

#range 可定制的数字列表
for i in range(10):
    print(i)

结果：

0
1
2
3
4
5
6
7
8
9

 

for i in range(1,10):也是顾头不顾尾
    print(i)

输出：

1
2
3
4
5
6
7
8
9

for i in range(1,10,2):
    print(i)
输出：

1
3
5
7
9

 

for i in range(10,1,-1):
    print(i)

输出：

10
9
8
7
6
5
4
3
2

 

print(range(10))  #range(0, 10)

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

for i in range(len(l1)-1,-1,-1):
    if i % 2 == 1:
        del l1[i]
print(l1)     #['alex', 'taibai', '老男孩']

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

结果：['k1', 'k2', 'k3']

for i in l1:
    del dic[i]
print(dic)  #{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'r': 666}

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

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

结果：

1 <class 'int'>
alex <class 'str'>
['alex', 1, 2] <class 'list'>

 

9、小数据池

python中有小数据池的概念

int、str只有他们有小数据池的概念，其他的数据类型没有

 

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

#深浅copy
#赋值运算，它们共用一个列表

a = [1,2,3]
b = a
a.append(666)
print(a,b)

结果：[1, 2, 3, 666] [1, 2, 3, 666]

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

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

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

#深copy 对于深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]))

结果：

[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33]]
41402776 41403736

 

10、编码二

#对于英文
s = 'laonanhai'   对于字符串来说，表现形式是这个（表现形式就是你能看到的），内部编码是unicode
print(s,type(s))

s1 = b'laonanhai'    对于bytes来说，表现形式是这个，内部编码方式为非unicode（非unicode包括utf-8，gbk，gb2312等等等等，只要不是unicode就行）
print(s1,type(s1))

结果：

laonanhai <class 'str'>
b'laonanhai' <class 'bytes'>

----------------------------------------

#对于中文：
s = '中国'
print(s,type(s))

s1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
print(s1,type(s1))
结果：

中国 <class 'str'>
b'\xe4\xb8\xad\xe5\x9b\xbd' <class 'bytes'>

 

-----------------------------------------------------

#转化
s = 'laonanhai'
s2 = s.encode('utf-8')  #str -->bytes encode 编码
s3 = s.encode('gbk')
print(s2,s3)

结果：b'laonanhai' b'laonanhai'
--------------------------------

s = 'laonanhai'

s2 = s.encode('utf-8')  #str -->bytes encode 编码
s3 = s.encode('gbk')
print(s2)
print(s3)
ss = s2.decode('utf-8')  # bytes ---> str decode 解码
print(ss)
结果：

b'laonanhai'
b'laonanhai'
laonanhai