02---python基础 (二)（-基础数据类型-）

int

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

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

bool值：True,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

print(int(True))
print(bool("")) # False

a = 0
print(int(a),bool(a))
a = 123
print(str(a),type(a))

str

s = 'python自动化运维21期'
s1 = s[0]
print(s1)
s2 = s[2]
print(s2)
s3 = s[-1]
print(s3)
s4 = s[-2]
print(s4)

1. 切片

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

s = 'python自动化运维21期'
s1 = s[:6] #顾头不顾尾
print(s1)

s2 = s[6:9]
print(s2)

s3 = s[:5:2]
print(s3)

s4 = s[:]
print(s4)

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

- capitalize 首字母大写，其他字母小写

s = 'oldBoy'
s1 = s.capitalize()
print(s1)

- 全部大写upper() 全部小写lower()

s2 = s.upper()
s3 = s.lower()
print(s2,s3)

code = 'QeAr'.upper()
your_code = input('请输入验证码:').upper()
if your_code == code:
    print('验证成功')

- 大小写反转 swapcase()

s4 = s.swapcase()
print(s4)

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

s = 'alex wusir*oldboy3taibia'
s5 = s.title()  # Alex Wusir*Oldboy3Taibia
print(s5)

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

s6 = s.center(30)
s6 = s.center(30,"*")
print(s6)
s = 'oldBoy'
*** startswith endswith
s7 = s.startswith('o')
s7 = s.startswith('ol')
s7 = s.startswith('oldBoy')
s7 = s.startswith('Bo',3,5)
print(s7)

- strip 去除首尾的空格，制表符\t,换行符。不仅仅是去除空格

lstrip()首 、rstrip()尾

s = '   tyoyldBoyrte'
s8 = s.lstrip()  ###去除首空格  指定字母
print(s8)
s8 = s.strip()
print(s8)
s81 = s.strip('t')
print(s81)
s81 = s.strip('tey')
print(s81）


name = input('>>>').strip()
if name == 'oldboy':
    print('验证成功')

- split (str —> list) 字符串转化为列表

s1 = 'oldboy,wusiry,alexy'
s = 'oldboywusiroalex'
l = s.split()
print(l)           # ['oldboywusiroalex']
l = s1.split(',')
print(l)           # ['oldboy', 'wusiry', 'alexy']
l2 = s.split('o')  
print(l2)          # ['', 'ldb', 'ywusir', 'alex']

l2 = s.split('o',1)  
print(l2)           # ['', 'ldboywusiroalex']

- join 将list —>str 将列表转化为字符

s = 'oldBoy'
s9 = '+'.join(s)
s9 = '_'.join(s)
print(s9)
l1 = ['oldboy','wusir','alex']
s91 = '_'.join(l1)
print(s91)

- replace 互换位置

s = '大铁锤fdsalj铁锤妹妹范德萨'
s10 = s.replace('铁锤','钢蛋')
print(s10)          # 大钢蛋fdsalj钢蛋妹妹范德萨

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

s = 'oldBoy'
ind1 = s.find('d')
print(ind1)
ind2 = s.find('o')
print(ind2)
ind3 = s.find('A')
print(ind3)
ind4 = s.index('A')
print(ind4)

格式化输出format

res='我叫{}今年{}岁，爱好{}'.format('egon',18,'male')
print(res)
res='我叫{0}今年{1}岁，爱好{2},我依然叫{0}'.format('egon',18,'male')
print(res)
res='{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res)

- len 总计 - count 计数

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

- isalnum、 isalpha、 isdigit

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

list列表

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

增

- append 在最后追加

l = ['刘', 'alex', 'wusir', 'taibai', 'ritian']
l.append('葫芦')
l.append([1,2,3])
print(l)

- insert 插入

l = ['刘', 'alex', 'wusir', 'taibai', 'ritian']
l.insert(1,'景nvshen')
print(l)

- 迭代着添加

l = ['刘', 'alex', 'wusir', 'taibai', 'ritian']
l.extend('alex')
l.extend(['111',222,333])
print(l)

删

*- pop 有返回值 按照索引删除*

l = ['刘', 'alex', 'wusir', 'taibai', 'ritian']
print(l.pop(0))
print(l)

- remove

l.remove('alex')
print(l)

- clear 清空列表

l.clear()
print(l)

- del 内存级别删除列表 按索引删除

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

- 切片删除

del l[:3]
print(l)

改

- 按照索引改

l = ['刘', 'alex', 'wusir', 'taibai', 'ritian']
l[0] = '孟'
print(l)
print(l[2])
l[2] = '武藤兰'
print(l)

- 按照切片去改

l = ['刘', 'alex', 'wusir', 'taibai', 'ritian']
l[1:2] = 'abc'
print(l)
l[1:3] = [111,222,333,444]
print(l)

查

- 按照索引去查询，按照切片去查询

for i in l:
    print(i)

- 计数 count len index(通过元素找索引)

l1 = [1,2,1,2,1,1,3,4]
#其他方法：
#count 计数
print(l1.count(1))
#len
print(len(l1))
#通过元素找索引
print(l1.index(2))

- sort 排序

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

#reverse
l2.reverse()
print(l2)

小题

#列表的嵌套
l1 = [1, 2, 'alex', 'wusir',['oldboy', 'ritian',99], 'taibai']
#1,将'alex'全部变成大写，放回原处。

l1[2] = 'ALEX'
print(l1[2].upper())
l1[2] = l1[2].upper()
print(l1)


#2.给['oldboy', 'ritian', 99] 追加一个元素‘女神’。 一个方法

# l1[-2].append('女财神')
# print(l1)



#3，将'ritian'首字母大写，放回原处。

# l1[-2][1] = l1[-2][1].capitalize()
# print(l1)



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

l1[-2][-1] = str(l1[-2][-1] + 1)
print(l1)

l1[-2][-1] = str(l1[-2][-1]) + '0'
print(l1)

dict 字典

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

增

setdefault() :有则不变，无则添加

dic = {'name':'taibai','age':21,'hobby':'girl',}

dic['high'] 有则覆盖，无则添加
dic['high'] = 180
dic['name'] = 'ritian'
print(dic)
dic.setdefault() 有则不变，无则添加
dic.setdefault('high')
dic.setdefault('high',180)
dic.setdefault('name','日天')
print(dic)

删

- pop : 有返回值

print(dic.pop('name'))  # 返回值 对应的值
print(dic.pop('name1','没有此key sb'))
print(dic)
print(dic)

- clear() 清空

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

- popitem() #随机删除，返回值

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

- del

del dic
print(dic)
del dic['age']
print(dic)

改

dic['name'] = '老男孩'
print(dic)

- update

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

查

print(dic['name'])
print(dic['name2'])

- get

print(dic.get('name1'))
print(dic.get('name1'))
print(dic.get('name1','没有此key，sb'))

- keys() 只显示key

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl','aaa':'bbb' }
print(list(dic.keys()))    #['name', 'age', 'hobby', 'aaa']
for i in dic.keys():
    print(i)    
#显示 
#name
#age
#hobby
#aaa

- values() 只显示值

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl','aaa':'bbb' }
print(dic.values())   # dict_values(['taibai', 21, 'girl', 'bbb'])
for i in dic.values():
    print(i)
#taibai
#21
#girl
#bbb

- items 以元祖的形式显示出来

#dic.items():把字典以元祖显示 #list(dic.items())把显示的元祖以列表显示

print(list(dic.items()))  # [('name', 'taibai'), ('age', 21), ('hobby', 'girl'), ('aaa', 'bbb')]
for i in dic.items():
    print(i)
#('name', 'taibai')
#('age', 21)
#('hobby', 'girl')
#('aaa', 'bbb')

- 分别赋值

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)
for i in dic.items():
    print(i)



dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl','aaa':'bbb' }

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

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

len 计数

dic = {'aa': 'ab','ac':'ad'}
print(len(dic))   #2

- fromkeys

dic1 = dict.fromkeys('abc','张三')
print(dic1)   # {'a': '张三', 'b': '张三', 'c': '张三'}
dic2= dict.fromkeys([1,2,3],'李四')
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)


#3.1，将ladyboy首字母大写。

dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
print(dic)

tuple 元祖

不可变元素

tu = (11,2,True,[2,3,4],'alex')
for i in tu:
    print(i)
#11
#2
#True
#[2, 3, 4]
#alex

print(tu[1])     # 2
print(tu[:3:2])  # (11, True)
print(tu.index(True))   # 2
print(tu.count(2))      # 1
print(len(tu))          # 5
tu[-2].append(666)
print(tu)     # (11, 2, True, [2, 3, 4, 666], 'alex')

set 集合

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

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]

增

- add

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

- update

set1.update('abc')
print(set1)    # {'ritian', 'alex', 'wusir', 'egon', 'b', 'a', 'barry', 'c'}

删

- pop 随机删除一个元素

set1 = {'alex','wusir','ritian','egon','barry'}

set1.pop()  # 随机删除一个元素
print(set1)    # {'barry', 'egon', 'ritian', 'alex'}

- remove # 删除一个元素

set1.remove('alex')  # 删除一个元素
print(set1)    # {'egon', 'ritian', 'barry', 'wusir'}

- clear 清空集合

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

- del 删除集合

del set1  # 删除集合
print(set1)

交集、并集、差集、反差集

交集： （& intersectio）

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

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(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}

issubset、issuperset、frozenset

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

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

print(set2 > set1)     #True
print(set2.issuperset(set1))  #True   测试是否 set1 中的每一个元素都在 set2 中 

s = frozenset('barry')       #创建固定的无序集合
s1 = frozenset({4,5,6,7,8})
print(s,type(s))     # frozenset({'a', 'b', 'y', 'r'}) <class 'frozenset'>
print(s1,type(s1))   # frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>

copy 小数据池

# id == is
a = 'alex'
b = 'alex'
print(a == b)  # True 数值
print(a is b)  # True 内存地址
print(id(a))   # 2409263247688   内存ID号
print(id(b))   # 2409263247688

深浅copy

赋值运算，它们共用一个列表

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

---

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

---

浅copy

---

对于浅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))   #   2736276933640 2736276951752

---

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])) # 1420042013704  1420042013704

深copy

---

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

---

import copy     # 调用copy 模块
l1 = [1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1,l2)                   # [1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33]]
print(id(l1[-1]),id(l2[-1]))   # 2561063915272 2561063974088

整体回顾

int:
    bit_lenth
str:
    upper(),lower（） 全大写，全小写
    catlize 首字母大写，其他字母小写
    strip去除空格，去除换行符，制表符，等或者指定字符。
    split（）分割，str ---> list
    replace() 替换
    startswith endswith  有切片，判断是以... 开头或者结尾
    count 计算元素的个数 有切片
    center() 居中，可以有填充物
    join()  '_'.join(iterable)  list(每个元素必须是str) --> str
    find，index 通过元素找索引。区别：index找不到会报错。
    title 每个单词首字母大写。
    isdigit()全部是数字
    isalpha()全部是字母。
    isalnum()数字或者字母组成。
    swapcase()大小写反转。
    fomart
    len 测量长度，个数。

list：
    增：
        append() 追加。
        insert() 插入，指定位置。
        extend() 迭代着追加。
    删：
        pop 按照索引，下标。有返回值。
        remove，按照元素删除。
        del：
            1，按照索引删除。
            2，按照切片删除。
        clear：清空。
    改：
        索引：
            li[1] = 666
        切片：
            li[1:4] = '1234'

    查：
        索引查，切片，for循环。

字典：dic = {'name':’老男孩','age':45}
    增：
        1,setdefault:如果存在，则不变，否则，添加。
        2，dic['key1'] = 'value1' 有则替换，无则添加。
    删：
        pop 按照键删除，有返回值。
        popitem 随机删除。
        clear清空。
        del 按照键去删除。
    改：
        update：覆盖添加
        dic['key1'] = 'value1'
    查：
        dic.get()
        dic['key1']
        dic.keys() dic.values() dic.items()
id  is  ==