基础数据类型补充，及capy daty7

1,基础数据类型,总结补充.

int:bit_lenth()
    str:
        captilze() 首字母大写,其余小写.
        upper()   全大写.
        lower()   全小写.
        find()    通过元素找索引,没有返回-1,有切片.
        index()   通过元素找索引,没有回报错.有切片
        swapcase()  大小写反转.
        strip() 去除前后端的空格,\n,\t,
        strip('abc') 去除前后端的a ,b,c三个元素,
        ltrip ,rtrip
        title 非字母隔开的部分,首字母大写
        split  str---> list  默认以空格(可以设定分隔符),
        startswith  判断s以什么开头,返回bool值,可以切片
        endswith 判断以什么结尾,返回bool值,可以切片
        replace(old,new) 默认不写次数,全体换
        center 以其为中心,默认填充物 空格.
        count 计算元素出现的次数.
        len() 测量字符串的长度.
        join   '' '*' '_'....   .join(interable)
        isalpha()  全都是字母组成
        isdigit()  全都是数字组成
        isalnum()  全都是字母或者数字
        '%s' %(name)
        name1 = 'taibai '
        '%(name)s' %{name:name1}
        format
        '{}{}{}'.format(name,age,hobby)
        '{0}{1}{2}{1}'.format(name,age,bobby)
        '{name},{age}'.format(age=12,name='太白')

int数字

str字符串

s = ' ' #只能是以至少一个空格组成的字符串(全空格)
print(s.isspace())

tuple元祖

tu = (1)
tu1 = (1,)
print(tu,type(tu))
print(tu1,type(tu1))
tu = ('alex')
tu1 = ('alex',)
print(tu,type(tu))
print(tu1,type(tu1))
tu = ([1,2,3])
tu1 = ([1,2,3],)
print(tu,type(tu))
print(tu1,type(tu1))
当元组只有一个元素组成并且没有','
则该元素是什么数据类型,整体就是什么数据类型.
tu.append('')
print(tu)

list

l1 = [111,222,333,444,555]
for i in range(len(l1)):
                # i = 0               i = 1             i = 2    i = 3
    print(l1)
    del l1[i]
    print(l1)   # [222,333,444,555]    [222,444,555]   [222,444]
print(l1)

 l1 = [111,222,333,444,555] 将索引为奇数位的元素删除.
l1.pop(222)
l1.remove(1)

方法一:
l1 = [111,222,333,444,555]
l2 = []
for i in range(len(l1)):
    if i % 2 == 0:
        l2.append(l1[i])
l1 = l2
print(l1)

方法二:
l1 = [111,222,333,444,555]
for i in range(1,len(l1)):
    if i <= 2 :
        l1.pop(i)
print(l1)

方法二:
l1 = [111,222,333,444,555,666,777]
#
del l1[1::2]
print(l1)
l1 = [111,222,333,444,555]
for i in range(len(l1)-1,0,-1):
    if i % 2 == 1:
        del l1[i]
print(l1)

在循环一个列表时,如果要是删除某些或者某类元素,容易出错.

fromkeys()

dic = dict.fromkeys('abc','alex')
print(dic)
dic1 = dict.fromkeys([1,2,3],[])
print(dic1)
dic1[1].append('alex')
print(dic1)

dic = {'k1':'alex','k2':'太白','k3':'日天','name':'wusir'}
不可变的数据类型:可哈希
for i in dic:
    if 'k' in i:
        del dic[i]

l1 = []
for i in dic:
    if 'k' in i:
        l1.append(i)
print(l1)

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

在循环一个字典时,如果删除某些键值对,可能会报错.

数据类型之间的转化:
int <---> str
int <---> bool
str <--->.bool
     split
str <------> list
     join
tuple <---> list
l1 = [1,2,3]
tu = tuple(l1)
l2 = list(tu)
print(tu,l2)

dict专属类型:与list转换
dic = {'k1':'alex','k2':'太白','k3':'日天','name':'wusir'}
print(list(dic.keys()))
print(list(dic.values()))
print(list(dic.items()))

2,深浅copy.

l1 = [1,2,3,4]
l2 = l1
l1.append(5)
print(l1,l2)
对于赋值运算,就是共同指向一个内存地址.

s1 = 'alex'
s2 = s1
s1 = 'alex2'
print(s1,id(s1))
print(s2,id(s2))

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

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

对于浅copy来说,第一层都是独立的内存地址,从第二层开始,都是指向同一个内存地址,一变都变.
import copy

l1 = [1,[22,33,],2,3]
l2 = copy.deepcopy(l1)
l1.append(777)
l1[1].append(666)
print(l1,id(l1),id(l1[1]))
print(l2,id(l2),id(l2[1]))
对于深copy,无论多少层,在内存中都是两个独立的内存地址.
l1 = [1,[1,2],2,3]
l2 = l1[:]  # 是浅copy
l1[1].append(111)
print(l1,l2)
l2 是什么?