python基础数据类型，集合及深浅copy

一 数据类型定义及分类 

　　我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，
因此，在每个编程语言里都会有数据类型，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字，你想让他处理文字，就传字符串类型。
以下为查看数据类型的方法。

>>> a= 2**64
>>> type(a)   #type()是查看数据类型的方法
<type 'long'>
>>> b = 2**60
>>> type(b)
<type 'int'>

    1.1  数字int

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

#bit_length() 当十进制用二进制表示时，最少使用的位数
v = 11   （0000 1011）
data = v.bit_length()
print(data)
运行后显示  4

   1.2 布尔值bool

       True，False。就是反应条件的正确与否。

        0  false

        1  true

    1.3 str 字符串  

      在python中凡是用引号引起来的都是字符串类型。引号可以是单引号‘’，双引号“”，多引号“““”””  

  其中，要打印多行字符串必须用多引号，如下：
         msg = '''
            今天我想写首小诗，
            歌颂我的同桌，
              '''
           print(msg) 

   1.3.1字符串拼接
>>> name
'Alex Li'
>>> age
'22'
>>> name + age  #相加其实就是简单拼接
'Alex Li22'
>>>
>>> name * 10 #相乘其实就是复制自己多少次，再拼接在一起
'Alex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex Li'

注意，字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接

>>> type(name),type(age2)
(<type 'str'>, <type 'int'>)
>>>
>>> name + age2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects 
#错误提示数字 和 字符 不能拼接

    1.3.2 字符串的索引与切片。

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

a = 'ABCDEFGHIJK'
print(a[0])
print(a[2])
显示 A C

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

a = 'ABCDEFGHIJK'
print(a[0:3])= print(a[:3])

结果为ABC。原则为顾头不顾腚，最后一位要多加1
print(a[:]) #默认到最后，取所有。 
print(a[0:-1]) #-1就是最后一个 
print(a[0:5:2]) #加步长，隔2个取一个。
print(a[5:0:-2]) #反向加步长，一般为数字小的在前。反之步长取负。

   1.3.3   用法    

                       s = 'oldBoy'

•     s1=s.capitalize()   首字母大写，其他字母小写 *  ------------------运行结果：Oldboy
•     s1=s.upper() 字母全部大写 ***          ------------OLDBOY
•     s1=s.lower() 字母全部小写 ***         ----------------oldboy
•     s1=s.swapcase() 字母大小写翻转 * ----------------------------OLDbOY                                       

•                   s = 'old Boy xyn'

•     s1=s.title()  将用非字母元素隔开的单词，首字母大写 *  ---------------- Old Boy Xyn
•     s1=s.center( 30，"*") 居中，长度(30)自己设定，长度为总字符串的长度，即所有*加上old Boy xyn的长度默认填充物为空格 *  
•     s1=s.startswith()  or  endswith *** 判断以什么字母开头结尾，是的话显示true，否则false    -------s7 = s.startswith('ol')，判断是否以ol开头
•     s1=s.strip() 去除字符串首尾的全部空格 ，换行符/n， 制表符/t 以及设定的字母   s1=s.strip('t') 去除字符串首尾的字母t   还有只去掉左边的lstrip（），只去掉右边的rstrip（）。
•       示例：防止输入时多输入空格

       name = input('请输入用户名：').strip()

       if name == 'xyn':
          print('成功！')

•     s1=s.spilt()    等于str----list，默认将以空格方式隔开的字母转换为list ，s1=s.spilt(’o‘，2) 已字母o为隔开点为转换为list，设置切割次数为2------运行结果----['', 'ldB', 'y wusir alex']

•         示例                    

•                     s = 'oldBoy wusir alex'
                      s8 = s.split()-----------------运行结果 -----['oldBoy', 'wusir', 'alex']

•     s1=' '.join(s)   可以将列表list转换为str，list内必须都为str类型，将元素以任意形式拼接起来。

•      示例
•                                   s2 = 'ABC'

                    s3 = '_'.join(s2) -------结果：A_B_C        

•  s1=s.replace （'old','new',次数）  替换内容       

•  s1=s.find() 通过元素找索引位置，找不到返回-1     s1=s.index()   通过元素找索引位置，找不到报错

公共方法(元组，列表，字符串) --- len 与count：

    1 Len (s) 显示s的长度       ---------      print（len（s））
    2 count（'d'）  显示d出现几次   ------  print（s.count（‘d’））
    3 is系列----用于判断，看结果返回true 或false

           name='jinxin123'

     print(name.isalnum()) #字符串由字母或数字组成

     print(name.isalpha()) #字符串只由字母组成

     print(name.isdigit()) #字符串只由数字组成

1.4 list 列表     

    定义： 列表是python中的基础数据类型之一，它是以[ ]括起来，每个元素以逗号隔开，而且里面可以存放各种数据类型比如： li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

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

    1.4.1列表的增

li = ['老男孩','wusir','b','xyn',3,'a']

   （1）append        增加到最后

           li.append('aaa') #增加到最后--------- 运行后显示['老男孩', 'wusir', 'b', 'xyn', 3, 'a', 'aaa']

           li.append([1,2,3]) #增加到最后 ----------------['老男孩', 'wusir', 'b', 'xyn', 3, 'a', [1, 2, 3]]

   （2） insert  任意位置增加

     li.insert(1,55) #按照索引去增加，在索引为1处加入55
     运行后显示  ['老男孩', 55, 'wusir', 'b', 'xyn', 3, 'a']

 （3）extend   迭代的增加，增加到最后
 li.extend(['q,a,w'])---['老男孩', 'wusir', 'b', 'xyn', 3, 'a', 'q,a,w']
 li.extend(['q,a,w','aaa'])--['老男孩', 'wusir', 'b', 'xyn', 3, 'a', 'q,a,w', 'aaa']
 li.extend('abc') --['老男孩', 'wusir', 'b', 'xyn', 3, 'a', 'a', 'b', 'c'] 
 li.extend('a,b,c')--['老男孩', 'wusir', 'b', 'xyn', 3, 'a', 'a', ',', 'b', ',', 'c']

    1.4.2 列表的删除

   （1）pop  按索引去删，唯一有返回值，会将删除的返回。 

       li.pop(1) #按照位置去删除，有返回值

   （2）remove   #按照元素去删除

    li.remove('a') 

（3）clear 清空列表
    li.clear()  运行后显示的为[]

（4） del   从内存中删除列表/按元素删除/按索引删除

     del li   运行后显示错误

     del li[1:3] #按照位置去删除，也可切片删除，没有返回值。

  1.4.3 列表的改

 li = [1,'wusir','b',2,3,'a']

（1）li[1] = 'wu'----按索引改
 
     li = [1,'wu','b',2,3,'a']

（2）li[1:3] = ['ab'] ------按切片区域元素删除，
      运行结果显示  [1, 'ab', 2, 3, 'a']

（3）li[1:3]= 'ab'-------按照最小元素划分添加进去

     运行结果 [1, 'a‘，’b', 2, 3, 'a']

1.4.4 列表的查    
    切片去查，或者循环去查。

1.4.5 其他方法：     
     （1）count记数      print(li.count(2)）
     （2）len  计算长度   print(len(li))
     （3）通过元素找索引   print （li.index(4）)----找到第一个就返回，找4的索引序号
     （4）排序  
             li.sort（）    -----从小到大排序

             li.sort（reverse=True）-----从大到小排
             li.reverse()-----倒序排列

1.4.6 列表的嵌套    
 练习题

li=[1,2,'alex','wusir',['oidboy','ritian',99],'taibai']

1 将alex 全部大写并放回原处

  #li[2]=li[2].upper()
  #li[2]=('ALEX')

2 将ritian首字母大写并放回原处

li[-2][1]=li[-2][1].capitalize()

3 将99 通过相加变成‘100’

  li[-2][-1]=str(li[-2][-1]+1)

  1.5 dict 字典

      字典的key是唯一的。key必须是不可变的数据类型，而且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组，bool。

      字典：存储数据多，关系型数据，查询速度快（二分查找）。

     字典的任何操作都是通过键（等于列表的索引）进行操作。

      1.5.1 字典的增

    dic['li'] = ["a","b","c"]  无则加，有则覆盖
    print(dic)
    setdefault  有则不变，无则添加
示例：dic.setdefault('k','v')
     print(dic) 
     {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
     dic.setdefault('k','v1') 
    {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
     print(dic)

 1.5.2 字典的删除

（1） dic.pop('name')---按照键去删除
     dic_pop = dic.pop("a",'无key默认返回值')    # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
     print(dic_pop)

（2） del dic["name"]  # 没有返回值。
     print(dic)

（3）dic.popitem()   #随机删除字典中的某个键值对
 dic_pop1 = dic.popitem() # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
 print(dic_pop1) 
('name','jin')

（4）dic.clear()  # 清空字典
   print(dic)  

1.5.3 字典的改

    （1）dic2.update(dic)   将dic的键值对覆盖添加到dic2中，有则改，无则加。

    （2）dic['name']='xyn'

   1.5.4 字典的查

        （1）print（dic.get（‘name’，‘没有此key’））  有则显示，无则默认返回none，也可以设置返回值。没有此key

        （2）循环着查

                 key（） 所有的键取出来  print（list（dic.key() ））

                values（）所有键的值取出来

                items（）

      1.5.5  字典的嵌套                        

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

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

         索引 切片    

如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。

# tu1 = (1)
# print(tu1,type(tu1))   类型是int
# tu2 = ('alex')
# print(tu2,type(tu2))   类型是str

 1.7  集合

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

      以下是集合最重要的两点：

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

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

1.7.1，集合的创建。

set2 = {1,2,'barry'}
print(set2)  
{1, 2, 'barry'} 

1.7.2，集合的增。

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

#update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)

1.7.3，集合的删。

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

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

del set1  # 删除集合
print(set1)

1.7.4，集合的其他操作：

　　（1） 交集。（&  或者 intersection）

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

　　（2） 并集。（| 或者 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,8}

　　（3） 差集。（- 或者 difference）

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

 　（4）反交集。 （^ 或者 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}

　　（5）子集与超集---返回true或者false

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

  （6）frozenset不可变集合，让集合变成不可变类型。

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

二 小数据池

  a==b       比较的是数值

  a is  b   is比较的是内存地址

  print（id（a））  打印出来的就是a的内存地址。必须要在终端试。 

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

 深浅copy

1，先看赋值运算。

l1 = [1,2,3,['barry','alex']]
l2 = l1

l1[0] = 111
print(l1)  # [111, 2, 3, ['barry', 'alex']]
print(l2)  # [111, 2, 3, ['barry', 'alex']]

l1[3][0] = 'wusir'
print(l1)  # [111, 2, 3, ['wusir', 'alex']]
print(l2)  # [111, 2, 3, ['wusir', 'alex']]

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

2，浅拷贝copy。

l1 = [1,2,3,['barry','alex']]

l2 = l1.copy()
print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2380296895816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2380296895048

l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2593038941128
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2593038941896

 
l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016
print(l2,id(l2[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

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

3，深拷贝deepcopy。

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

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

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

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

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