您的位置:新葡亰496net > 奥门新萄京娱乐场 > python全栈开荒,群集操作

python全栈开荒,群集操作

发布时间:2019-11-23 15:40编辑:奥门新萄京娱乐场浏览(194)

    1.join()

      将列表调换来字符串,并且种种字符之间用另二个字符连接起来,join前面总得是可迭代的指标(字符串,列表,元组,字典,集合),数字不可能迭代

    例如:

    1 s = ['a','b','c']
    2 s1 = '_'.join(s)
    3 print(s1)
    

    结果为:a_b_c

     

    功底数据类型的补给join()把列表转形成字符串,是迭代的秘技开展的拼接lst = ["alex", "dsb", "wusir", "xsb"]# 使用前面包车型的士字符串. 对前面包车型地铁列表进行拼接,拼接的结果是贰个字符串s = "_".joinprint###alex_dsb_wusir_xsbsplit()把字符串转产生列表lst = 'alex$dsb$wusir$xsb's = lst.splitprint####['alex', 'dsb', 'wusir', 'xsb']列表和字典都不可能再循环的时候一贯删除,要把删除的内容记录在新的列表中,然后在循环那些新列表,删除列表最合理的删减情势:1,把要去除的内容写在新列表中2,循环那几个新列表,删除老列表lst = ['篮球', '排球', '足球', '电游竞赛', '斯诺克']new_lst = []for i in lst:if '球' in i:new_lst.appendfor i in new_lst:lst.removeprint关于删除的切实可行的授课st = ["篮球", "排球" ,"足球", "电竞", "台球"]lst.clear()for el in lst:lst.removeprint # 删不干净.原因是: 删除一个. 成分的目录要重新排列, for循环向后走二个. 差贰个for i in range: # 0 1 2 3 4lst.popprint #[]lst = ["篮球", "排球" ,"足球", "电竞", "斯诺克"]# 最合理的删减格局:# 1. 把要刨除的剧情写在新列表中.# 2. 周而复始那么些新列表. 删除老列表# 须求: 删除列表中代球字的移位项目new_lst = []for el in lst:if "球" in el:new_lst.append # 记录要去除的剧情# 要删减的列表print# 循环新列表. 删除老列表for el in new_lst: # ['篮球', '排球', '足球', '台球']lst.removeprint字典列表和字典在被循环的时候是不能够去除的.1,把要去除的key保存在三个新列表中,2,循环这些列表.删除字典中的key:vlause##### 坑:铜锣湾,神坑 面试题:fromkeys() 帮大家创立字典的, 把第二个参数进行迭代.得到每风度翩翩项作为key和前边的value组合成字典#坑1: 再次回到新字典,和原先的字典没有涉嫌dic = {}d = dic.fromkeys('风扇哥', '很困')###会新建多个字典print#{}#坑2: 假使value是可变的数据类型,那么内部的两个key对应valued = dict.fromkeysprint#{'胡': [], '辣': [], '汤': []}d['胡'].append###key 对应的是同一个列表,key变可是value不改变print#{'胡': ['山西特色'], '辣': ['江苏特点'], '汤': ['河DongFeng味']}深浅拷贝1.= 从未有过创设新对象,只是把内部存款和储蓄器地址实行了复制从上到下独有八个列表被创立2.lst.copy 浅正片,只拷贝第生机勃勃层copy.deepcopy() 深拷贝,对象内部的享有内容都要拓宽拷贝.深度克隆.原型格局为啥要有深浅的正片?升高创设对象的速度,计算中最慢的,就是创设对象,需求分配内存. 最快的议程即是二进制流的方式张开复制.速度最快.

    python_day_7

    Python第三日 连串  5种数据类型  数值  字符串  列表  元组  字典

     

    目录

    Pycharm使用技能(转发卡塔 尔(英语:State of Qatar)

    Python第一天  安装  shell  文件

    Python第二天  变量  运算符与表达式  input()与raw_input()分歧  字符编码  python转义符  字符串格式化

    Python第八天 体系  5种数据类型  数值  字符串  列表  元组  字典

    Python第16日   流程序调节制   if else条件推断   for循环 while循环

    Python第三天   文件访谈    for循环访谈文件    while循环访问文件   字符串的startswith函数和split函数

    Python第四日   类型转变

    Python第七日   函数  函数参数   函数变量   函数再次回到值  多品种传值    冗余参数   函数递归调用   佚名函数   内置函数   列表表达式/列表重写

    Python第十四日  模块   包   全局变量和停放变量__name__    Python path

    Python第九天  面向对象  类定义   类的习性    类的办法    内部类   垃圾回笼机制   类的继承装饰器

    Python第十天   print >> f,和fd.write()的分别    stdout的buffer  规范输入 标准输出  规范错误   重定向 输出流和输入流

    Python第十九天    相当管理  glob模块和shlex模块    展开外界程序和subprocess模块  subprocess类  Pipe管道  operator模块   sorted函数   生成器  walk模块   hashlib模块

    Python第十七天     收罗主机新闻     正则表明式  无名分组   有名分组

    Python第五日   django 1.6   导入模板   定义数据模型   访谈数据库   GET和POST方法    SimpleCMDB项目   urllib模块   urllib2模块  httplib模块  django和web服务器整合  wsgi模块   gunicorn模块

    Python第十31日 系列化  pickle模块  cPickle模块  JSON模块  API的二种格式

    Python第二十四日  datetime模块 time模块   thread模块  threading模块  Queue队列模块  multiprocessing模块  paramiko模块  fabric模块  

     

     

     

     

    5种数据类型
    数值
    字符串 (序列)
    列表(序列)
    元组(序列)
    字典(可迭代对象卡塔尔

     

     

    序列
    序列:字符串、列表、元组
    队列的七个重大特色是目录操作符切开操作符

    • 目录操作符让大家得以从体系中抓取贰个特定类型
    • 切开操作符让我们能够获得连串的二个切成块,即生龙活虎部分行列

    队列的基本操作

    1. len(): 求类别的长短
    2. : 连接2个序列
    3. *: 重复种类成分
    4. in/not in: 剖断成分是不是在连串中
    5. max(): 重回最大值
    6. min(): 再次来到最小值
    7. cmp(x, y):比相当多个连串是不是等于 再次来到值大于0 ,等于0,小于0
      cmp:遵照字符串比较,字符串相比的标准正是二个字符多少个字符的可比,字符遵照ASCII码来相比,字符1比字符2小,所以gene1001低于gene2。

     


    数值类型

    • 整型  2^32个数字,范围-2,147,483,648到2147483647
    • 长整型  区分普通整型,需求在整数后加L或l。2345L,0x34al
    • 浮点型  0.0,12.0,-18.8,3e 7
    • 复数型  - 3.14j,8.32e-36j

    字符串''类型

    字符串是不可变数据类型
    有几种格局定义字符串类型
    str = 'this is a string'
    str = "this is a string"
    str = '''this is a string'''  或 """this is a string"""
    三重引号(docstring卡塔 尔(阿拉伯语:قطر‎除了能定义字符串仍可以用作注释
    python里面单引号和双引号未有其余差别

    n:换行
    str = "this is a nstring"

    字符串索引
    字符串是连串,能够经过索引取每种字符
    加号 :字符串连接符
    str = 'abcde'
    str[0] str[1]
    字符串切块
    str[start:end:step]
    step:为负数表示从右向左,步长为正数,start那多少个数字的值不要,步长为负数,end那么些数字的值不要

    >>> str[1:3]
    'bc'
    >>> str[:3]
    'abc'
    >>> str[3:]
    'de'
    >>> str[::1]
    'abcde'
    >>> str[::2]
    'ace'
    >>> str[-1]
    'e'
    >>> str[-4:-1]
    'bcd'
    >>> str[-2:-4:-1]
    'dc'

    字符串相关函数
    replace()
    split()
    join()
    strip()
    format()  :'{0},I'm {1},my E-mail is {2}'.format('Hello','Hongten','hongtenzone@foxmail.com')
    find()


    元组()类型
    元组和列表十三分相仿
    元组和字符串相疑似不可变的,不可变的意趣是元组里面包车型地铁要素不可能改进,举例a[-1] = xx 会报错

    一、集合

    2.字符串转换来列表:split()

    后生可畏. 前不久关键内容:

    - 元组能够积攒大器晚成多级的值

    元组平日用在客商定义的函数能够安全地运用一组值的时候,即被采用的元组的值不会转移。

    创设元组
    t= ()
    t= (2,) 应当要加逗号才是元组,不然会当普通字符串对待
    t = ('james', 'M')
    t = ('james', 'M',(1,)) 元组里面包涵元组
    j = 'sd'
    t = (j, 'M') 包括变量

    print t
    ('sd', 'M')

    print t[0] 再次来到第叁个成分

     

    元组操作

    • 元组和字符串同样归于连串类型,能够通过索引和切成条操作
    • 元组值不可变
      元组的拆分

      t = (1,2,3) a, b, c = t a 1 b 2 c 3

     

     

    M=2
    t = ('james', M,'gg','cc')
    for a in t:
        print a
    james
    2
    gg
    cc
    

     

     b=('a','b','a','d','a')
    print(b.count('a'))  计算'a'这一个因素豆蔻梢头共有稍许个


    列表[]类型

    列表(list)是管理大器晚成组有序项指标数据结构,即能够在列表中贮存多个队列的种类。
    列表是可变类型的数据类型
    创办列表
    list1 = []
    list2 = list()   list()函数
    list3 = ['a',1,2]
    list4 = ['a',1,(1,),['sdf','sww]]

    对某项目赋值,下标从0伊始
    list3[0] = 'b'

    列表操作

    • 取值
      切开和目录

      切片 l = list(range(10)) l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] l[5:0:-1] 输出:[5, 4, 3, 2, 1] l[5:4:-1] 输出:[5] l[:3:-1] 输出:[9, 8, 7, 6, 5, 4] l[0:3:-1] 输出:[] l[9::-1] 输出:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0] l[-2:]( l[-2:10:1]) 输出:[8, 9] l[2:]( l[2:10:1]) 输出:[2, 3, 4, 5, 6, 7, 8, 9] l[:-2]( l[0:-2:1]) 输出:[0, 1, 2, 3, 4, 5, 6, 7] l[0] 输出:0

      l[列表最小值:列表最大值:步进] 步长为正数情形下输出不饱含列表最大值 列表最小值下标从0开头 -1:9 -2:8

    - 添加
    list.append()
    list1[2].append('abc')  假使列表里面又有列表使用下标来访谈
    添加 list= list [6]  ,list2 =[1,2]   list = list list2

    • 删除
      del list[x] 删除某些元素  del list 删除全体列表
      list.remove(列表里面其实的值)
    • 修改
      list[] = x
    • 查找
      var in list
    • 插入
      list.insert(list[x],object)  在下标前插入五个对象
    • 排序
      list.sort()
    • 反转
      list.reverse()
    • 弹出
      list.pop([index])  重临四个因素并剔除那几个成分,参数是下标,未有参数会删除最终二个要素
    • 扩展
      list.extend(iterable)  可迭代的,比较append()方法能够追加三个值,l.extend(range(10))
    • 统计
      a = ['s','c','c']
      a.count('c')  总括'c'这一个成分大器晚成共有多少个

     

    Python归总列表,append()、extend()、 、 =
    1.append() 向列表尾巴部分扩展二个新因素,列表只占一个索引位,在原有列表上增添
    2.extend() 向列表尾巴部分扩张叁个列表,将列表中的每一种元素都增添进来,在原有列表上平添
    3. 直接用 号看上去与用extend()同样的效果,不过实际是生成了叁个新的列表存那八个列表的和,只可以用在三个列表相加上
    4. = 功用与extend()相似,向原列表追加一个新因素,在本来列表上平添

    图片 1


     

    字典{}类型

    字典是python中的唯黄金时代的炫丽类型(哈希表卡塔尔国
    字典对象是可变的,可是字典的键必须接收不可变对象,一个字典中能够使用区别门类的键值。
    跟redis的set类型相似,字典里的key无法再度,赋值的时候要是发现本来就有key则替换
    字典的方法:

    • keys() 重临全部key
    • values() 重返全部value
    • items() 重回二个列表,key和value在叁个元组里

    开创字典
    dic = {}
    dic = dict()

    dict()函数
    help(dict)

     

    字典创设
    第一种
    dict((['a',1],['b',2]))  #dict()函数情势1
    aa=dict((['a',1],['b',2]))
    print aa
    {'a': 1, 'b': 2}

    第二种
    dict(a=1, b=2)  #dict()函数方式2
    bb=dict(a=1, b=2)
    print bb
    {'a': 1, 'b': 2}

    第三种
    dd = {'line':1,'char':2,'word':3} 或dd = {1:1,2:2,3:3} 
    print dd

    {'char': 2, 'line': 1, 'word': 3}

    第四种
    info = {}  #开创贰个空字典
    info['name'] = 'name'
    info['age'] = 'age'
    info['gender'] = 'gender'
    print info
    {'gender': 'gender', 'age': 'age', 'name': 'name'}

     

     

    fromkeys()函数
    fromkeys(S[,v]) S钦定多个连串,v钦点value的值,默以为None。
    dic.fromkeys(range(3),100)
    In [4]: dic.fromkeys(range(3),100)
    Out[4]: {0: 100, 1: 100, 2: 100}
    fromkeys函数创立的字典须要赋值到另三个字典工夫保留
    ddict = {}.fromkeys(('x','y'), 100)

     

    update()函数
    将一个字典增多到另二个字典
    dict1 = {'Name': 'Zara', 'Age': 7}
    dict2 = {'Sex': 'female' }

    dict1.update(dict2)
    print "dict1 : %s" %  dict1

     

    get()函数
    python全栈开荒,群集操作。将代入key,返回value
    dict1 = {'Name': 'Zara', 'Age': 7}
    dict1.get('Age')
    print "dict1 : %s" %  dict1  返回7

     

    pop函数  删除字典里有个别key值
    dict1 = {'Name': 'Zara', 'Age': 7}
    python全栈开荒,群集操作。dict1.pop('Age')
    print dict1

     

    zip函数 dict函数 选拔大肆多少个(满含0个和1个卡塔尔系列作为参数,重临一个tuple列表
    x = [1, 2, 3]
    y = ['a', 'b', 'c']
    xyz = zip(x, y,)
    print xyz
    print dict(xyz)

     

    拜谒字典
    直接利用key访问:key官样文章会报错,能够行使has_key()或者in和not in判断。
    循环遍历  items()  ,iteritems()函数
    例:
    for i in dic.keys():
    for i in dic:
    print i 读取的是key
    print dic[i] 读取的是value

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

    建议接收iteritems函数,items函数会一回性把字典的兼具键值全体抽出来,而iteritems函数只会三遍收取贰个

    dict1 = {'Name': 'Zara', 'Age': 7}
    for i, o in dict1.iteritems():
        print i, o
    

     

     

     

    #!/usr/bin/python

    info = {}  成立二个空字典
    name = raw_input("Please input name: ")
    age = raw_input("Please input age: ")
    gender = raw_input('Please input (M/F): ')
    info['name'] = name
    info['age'] = age
    info['gender'] = gender
    for k, v in info.items():
    print "%s: %s" % (k, v)
    print 'main end'

     

     

    容器(container)
    容器是一种把多个元素组织在一起的数据结构,容器中的元素可以逐个地迭代获取,可以用 in , not in 关键字判断元素是否包含在容器中。通常这类数据结构把所有的元素存储在内存中(也有一些特列并不是所有的元素都放在内存)在Python中,常见的容器对象有:
    
    list, deque, ....
    set, frozensets, ....
    dict, defaultdict, OrderedDict, Counter, ....
    tuple, namedtuple, …
    str
    
    
    可迭代对象(iterable)
    刚才说过,很多容器都是可迭代对象,此外还有更多的对象同样也是可迭代对象,比如处于打开状态的files,sockets等等。
    但凡是可以返回一个 迭代器 的对象都可称之为可迭代对象
    
    
    什么是迭代器呢?
    它是一个带状态的对象,他能在你调用 next() 方法的时候返回容器中的下一个值,任何实现了 __next__() (python2中实现 next() )方法的对象都是迭代器
    
    
    序列:字符串、列表、元组
    序列跟迭代器不一样,序列对象没有next()方法
    
    
    生成器(generator)
    生成器算得上是Python语言中最吸引人的特性之一,生成器其实是一种特殊的迭代器,不过这种迭代器更加优雅。
    它不需要再像上面的类一样写 __iter__() 和 __next__() 方法了,只需要一个 yiled 关键字。 因此任何生成器也是以一种懒加载的模式生成值。,因此任何生成器也是以一种懒加载的模式生成值。
    
    例如数据库的全局唯一ID生成器,也是一种生成器
    
    
    生成器是迭代器,但是迭代器不一定是生成器,因为生成器是有状态的!!!!!!
    

     

        集结是严节的,不可重复的多寡集结。群集里面包车型大巴成分是不可哈希的(不可变类型卡塔 尔(英语:State of Qatar)(成分、字符串、数字卡塔 尔(英语:State of Qatar),可是集结自己不可哈希(所以群集做不了字典的键卡塔尔国。

       列表转变来字符串:join()

    1. 补偿底工数据类型的相关知识点

    2. str. join() 把列表形成字符串

    3. 列表无法再循环的时候删除. 因为索引会跟着变动
    4. 字典也不能够直接循环删除.把要刨除的剧情记录在列表中. 循环列表. 删除原列表, 字典中的数据
    5. fromkeys() 不会对原本的字典发生影响. 爆发新字典(神坑, 考试)
    6. set集合. 不重复, 无序.
    7. 想转变来什么.就用什么括起来
    8. 浓度拷贝

        首要意义:

     

    • 直接赋值. 多少个变量指向同二个对象.
    • 浅拷贝:只拷贝第豆蔻梢头层内容. copy()
    • 深度拷贝: 对象中的全部剧情都会被拷贝大器晚成份

      import copy
      copy.deepcopy()

          1.去重,把一个列表形成会集,就机关去重了。

    3.列表的去除(pop,remove,del,clear)

    07. 万恶之源-set集结,深浅拷⻉以致一些知识点补充
    本节首要内容:

          2.关联测验,测量检验两组数据以前的搅拌、差集、并集等关联。

      假如用for循环删除,第四个成分的目录就形成了第4个因素的目录,当时列表内部的目录在转移

    例如:

    1 lst = ['a','b','c','d']
    2 for i in lst:
    3     lst.remove(i)
    4 print(lst)
    

    结果为:['b','d']

    那儿内需创制贰个新的列表来记录原列表,然后for循环依次遍历新列表,删除原列表

    例如:

    1 lst = ['a','b','c','d']
    2 lst1 = []      #存放要删除的元素
    3 for i in lst:    #循环新列表
    4     lst1.append(i)    #将原列表的元素添加到新列表中
    5 for i in lst1:            #循环新列表
    6     lst.remove(i)       #删除原列表中的元素
    7 print(lst)
    8 print(lst1)    
    

    那时候结果为:[]

          ['a','b','c','d']

    1. 根底数据类型补充
    2. set集合
    3. 深浅拷⻉

        创设集结     

    4.字典的删减:

      和列表雷同,都是先创制三个新的字典,然后循环原字典,将各类成分增添到新字典中,循环新字典,删除原字典

      例如:

    dic = {'a':1,'b':2,'c':3,'d':4}
    dic1 = {}
    for i in dic:
        dic1.setdefault(i)
    for j in dic1:
        dic.pop(j)  #字典只能通过key来删除,而不能用索引删除
    print(dic)
    

    结果为:{}

    关键内容:
    ⼀. 底子数据类型补充
    ⾸先关于int和str在前边的上学中早就讲了十分七以上了. 所以剩下的⾃⼰看⼀看就可以了.
    我们补充给⼀个字符串基本操作

          set = {'a','b','c'}
          set = set({'a','b','c'})
          print(set)

    进而,列表和字典在循环的时候无法去除,字典在循环的时候无法校订大小

    fromkeys():用来成立五个新的字典,和原先的字典不妨,使用dict访问fromkeys()

      dic = dict.fromkeys('def',[4,5,6])

      print(dic)

    结果为:{'d':[4,5,6]'e':[4,5,6],'f':[4,5,6]}

     

    s = "corn".join(["王者荣耀","LOL",'CS','DOTA','魔兽世界'])
    print(s)
    

        1.去重  

    5.set集合:

    创建:  s = set()

    集结自个儿是可变的数据类型,不可哈希,有增加和删除改查操作

    集合中的成分是不可变的,不另行,可哈西,能够去重

    将列表去重:

          s = []

          s1 = set(s) #把列表转变成集合,实行去重新

          s2 = list(s1)#把会集调换来列表

    列表:
    循环删除列表中的每⼀个成分

          set = {1,2,3,3,4,5}

     

    lst = ['周杰伦','周润发','周星星','马化腾','周树人']
    l = []
    for i in lst:
        if i.startswith("周"):
            l.append(i)
    for i in l:
        lst.remove(i)
    print(lst)
    

          print(set)

    6.深浅拷贝

    import copy()

    浅拷贝:lst = []

        lst1 = lst[:]

        lst1 = lst.copy()

    甭管改动lst依然lst1,另三个也会变动(共用同二个内部存款和储蓄器地址)

    深拷贝:

        lst = []

        lst1 = copy.deepcopy(lst)  #创设了一个新的内部存款和储蓄器

    任凭改造lst依然lst1,另多少个都不会变动

     

    注意: 由于删除元素会诱致成分的目录更动, 所以轻便现身难点. 尽量不要再循环中向来去删 除成分. 能够把要删减的成分增多到另⼀个聚众中然后再批量删除.

        2.增  

    字典同上:

          set.add('asd')    #增加
          set.update('asd')   #迭代加,二个二个加

    # 字典也不能在循环的时候更改大小
    dic = {"a":"123", "b":"456"}
    for k in dic:
        dic.setdefault("c", "123")
    
    a = dict.fromkeys(["jj", 'jay', 'taibai'], "sb")  # 静态方法
    
    
    dic = {"a":"123"}
    s = dic.fromkeys("王健林", "思聪" ) # 返回给你一个新字典
    print(s)
    

        3.删除

    类型调换:
    元组 => 列表 list(tuple)
    列表 => 元组 tuple(list)
    list=>str str.join(list)
    str=>list str.split()
    转换成False的数据:
    0,'',None,[],(),{},set() ==> False

          set.remove('alex')  #按成分删

     

          set.pop()      #恣意删除

    ⼆. set集合
    set集结是python的⼀个基本数据类型. ⼀般不是很常⽤. set中的成分是不重复的.⽆序的.⾥
    ⾯的成分必需是可hash的(int, str, tuple,bool), 大家得以那样来记. set正是dict类型的数额但
    是不保留value, 只保存key. set也⽤{}表⽰
    静心: set群集中的成分必得是可hash的, 但是set本⾝是不可hash得. set是可变的.

          set.clear()       #清空,重临值为 set()

    set1 = {'1','alex',2,True,[1,2,3]} # 报错
    set2 = {'1','alex',2,True,{1:2}} # 报错
    set3 = {'1','alex',2,True,(1,2,[2,3,4])} # 报错
    

          del set       #删除字集

    set中的成分是不另行的, 且⽆序的.

        4.查

    s = {"周杰伦", "周杰伦", "周星星"}
    print(s)
    # 结果:
    # {'周星星', '周杰伦'}
    

          print(set)

    使⽤这些天性.我们能够使⽤set来去掉重复

        5.任何操作

    # 给list去重复
    lst = [45, 5, "哈哈", 45, '哈哈', 50]
    lst = list(set(lst)) # 把list转换成set, 然后再转换回list
    print(lst)
    

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

    set群集增删改查

          1卡塔尔国交集(set1和set2均等成分卡塔 尔(英语:State of Qatar)

    1. 增加

      s = {"刘嘉玲女士", '关之琳(Guan Zhilin卡塔尔', "王祖贤(英文名:Joey Wong卡塔 尔(阿拉伯语:قطر‎"} s.add("郑裕玲") print(s) s.add("郑裕玲") # 重复的从头到尾的经过不会被增添到set会集中 print(s) s = {"刘嘉玲女士", '关之琳女士', "王祖贤(Joey Wong卡塔尔国"} s.update("麻花藤") # 迭代改良 print(s) s.update(["张曼⽟", "李若彤","李若彤"]) print(s)

    2. 删除

      s = {"刘嘉玲(Liu Jialing卡塔 尔(英语:State of Qatar)", '关之琳(Guan Zhilin卡塔尔国', "王祖贤(英文名:Joey Wong卡塔尔国","张曼⽟", "李若彤女士"} item = s.pop() # 随机弹出⼀个. print(s) print(item) s.remove("关之琳(guān zhī lín 卡塔 尔(阿拉伯语:قطر‎") # 直接删除成分 # s.remove("⻢⻁疼") # 荒诞不经此个成分. 删除会报错 print(s) s.clear() # 清空set会集.要求注意的是set会集要是是空的. 打字与印刷出来是set() 因为要和dict区分的. print(s) # set()

    3. 修改

      # set会集中的数据未有索引. 也尚无艺术去牢固⼀个成分. 所以未有艺术进⾏直接改革. # 我们可以采⽤先删除后增多的⽅式来产生改进操作 s = {"刘嘉玲(liú jiā líng 卡塔尔国", '关之琳(guān zhī lín 卡塔尔国', "王祖贤(英文名:Joey Wong卡塔 尔(阿拉伯语:قطر‎","张曼⽟", "李若彤(Li Ruozhen卡塔 尔(阿拉伯语:قطر‎"} # 把刘嘉玲(Liu Jialing卡塔 尔(阿拉伯语:قطر‎改成赵本⼭ s.remove("刘嘉玲(liú jiā líng 卡塔尔国") s.add("赵本⼭") print(s)

    4. 查询

      # set是⼀个可迭代对象. 所以能够进⾏for循环 for el in s: print(el)

    5. 常⽤操作

      s1 = {"刘能", "赵四", "⽪⻓⼭"} s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"} # 交集 # 五个聚众中的共有元素 print(s1 & s2) # {'⽪⻓⼭'} print(s1.intersection(s2)) # {'⽪⻓⼭'} # 并集 print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'} print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'} # 差集 print(s1 - s2) # {'赵四', '刘能'} 拿到第⼀内部单独存在的 print(s1.difference(s2)) # {'赵四', '刘能'} # 反交集 print(s1 ^ s2) # 多少个汇集中独立存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵四'} print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'} s1 = {"刘能", "赵四"} s2 = {"刘能", "赵四", "⽪⻓⼭"} # ⼦集 print(s1 < s2) # set1是set2的⼦集吗? True print(s1.issubset(s2)) # 超集 print(s1 > s2) # set1是set2的超集吗? False print(s1.issuperset(s2))

            print(set1 & set2)
            print(set1.intersection(set2))

    set集结本⾝是足以发⽣改动的. 是不可hash的. 大家能够使⽤frozenset来保存数据. frozenset是不可变的. 也正是⼀个可哈希的数据类型

          2卡塔 尔(阿拉伯语:قطر‎并集(set1和set2享有的因素卡塔 尔(英语:State of Qatar)

    s = frozenset(["赵本⼭", "刘能", "⽪⻓⼭", "⻓跪"])
    dic = {s:'123'} # 可以正常使⽤了
    print(dic)
    

            print(set1 | set2)
            print(set1.union(set2))

    以此不是很常⽤. 理解⼀下就足以了

          3卡塔尔国差集(set1里有set2里未有的因素卡塔尔国

    三. 深浅拷⻉

            print(set1 - set2)
            print(set1.difference(set2))

    lst1 = ["⾦⽑狮王", "紫衫⻰王", "⽩眉鹰王", "⻘翼蝠王"]
    lst2 = lst1
    print(lst1)
    print(lst2)
    lst1.append("杨逍")
    print(lst1)
    print(lst2)
    #结果:
    ['⾦⽑狮王', '紫衫⻰王', '⽩眉鹰王', '⻘翼蝠王', '杨逍']
    ['⾦⽑狮王', '紫衫⻰王', '⽩眉鹰王', '⻘翼蝠王', '杨逍']
    dic1 = {"id": 123, "name": "谢逊"}
    dic2 = dic1
    print(dic1)
    print(dic2)
    dic1['name'] = "范瑶"
    print(dic1)
    print(dic2)
    #结果:
    {'id': 123, 'name': '谢逊'}
    {'id': 123, 'name': '谢逊'}
    {'id': 123, 'name': '范瑶'}
    {'id': 123, 'name': '范瑶'}
    

          4卡塔 尔(阿拉伯语:قطر‎反交集(set1和set2不如的要素卡塔尔国

    对此list, set, dict来讲, 直接赋值. 其实是把内部存款和储蓄器地址交给变量. 并非复制⼀份内容. 所以. lst1的内部存款和储蓄器指向和lst2是⼀样的. lst1退换了, lst2也发⽣了转移

            print(set1 ^ set2)
            print(set1.symmetric_difference(set2))

    浅拷⻉

          5卡塔 尔(阿拉伯语:قطر‎子集(set1里成分set2里是还是不是都有卡塔尔

    lst1 = ["何炅", "杜海涛","周渝⺠"]
    lst2 = lst1.copy()
    lst1.append("李嘉诚")
    print(lst1)
    print(lst2)
    print(id(lst1), id(lst2))
    #结果:
    #两个lst完全不⼀样. 内存地址和内容也不⼀样. 发现实现了内存的拷⻉
    lst1 = ["何炅", "杜海涛","周渝⺠", ["麻花藤", "⻢芸", "周笔畅"]]
    lst2 = lst1.copy()
    lst1[3].append("⽆敌是多磨寂寞")
    print(lst1)
    print(lst2)
    print(id(lst1[3]), id(lst2[3]))
    #结果:
    ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']]
    ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']]
    4417248328 4417248328
    

            print(set1 < set2)
            print(set1.issubset(set2))

    浅拷⻉. 只会拷⻉第⼀层. 第⼆层的内容不会拷⻉. 所以被叫做浅拷⻉

          6卡塔 尔(英语:State of Qatar)超集(set2里是或不是有se1全体因素卡塔 尔(英语:State of Qatar)

    深拷⻉

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

    import copy
    lst1 = ["何炅", "杜海涛","周渝⺠", ["麻花藤", "⻢芸", "周笔畅"]]
    lst2 = copy.deepcopy(lst1)
    lst1[3].append("⽆敌是多磨寂寞")
    print(lst1)
    print(lst2)
    print(id(lst1[3]), id(lst2[3]))
    #结果:
    ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']]
    ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅']]
    4447221448 4447233800
    

          7卡塔 尔(英语:State of Qatar)不可变合集(frozenset卡塔 尔(阿拉伯语:قطر‎      

    都不⼀样了. 深度拷⻉. 把成分内部的成分完全进⾏拷⻉复制. 不会产⽣⼀个改换另⼀个跟着变动的主题材料

            set1 = {4,5}
            set2 = frozenset(set1)
            print(set2,type(set2))

    补偿⼀个知识点:

            结果:frozenset({4, 5}) <class 'frozenset'>

    末尾我们来看⼀个⾯试题:

    二、深入copy

    a = [1, 2]
    a[1] = a
    print(a[1])
    

        1.赋值运算     


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

    作业;

          l1[0] = 111
          print(l1 is l2)

    一.判断一个数是否是水仙花数, 水仙花数是一个三位数, 三位数的每一位的三次方
    的和还等于这个数. 那这个数就是一个水仙花数, 例如: 153 = 1**3   5**3   3**3
    
    h = 0
    s = input("请随机输入一个三位数:")
    for i in s:
        h = h   int(i) ** 3
    if h == int(s):
        print('这是水仙花数')
    else:
        print("不是水仙花数")
    
    二.给出一个纯数字列表. 请对列表进行排序(升级题).
    思路:
    1.完成a和b的数据交换. 例如, a = 10, b = 24 交换之后, a = 24, b = 10
    2.循环列表. 判断a[i]和a[i 1]之间的大小关系, 如果a[i]比a[i 1]大. 则进行互换.
    循环结束的时候. 当前列表中最大的数据就会被移动到最右端.
    3.想一想, 如果再次执行一次上面的操作. 最终第二大的数据就移动到了右端. 以此类推.
    如果反复的进行执行相应的操作. 那这个列表就变成了一个有序列表.
    
    ls = [10, 12, 32, 45, 88, 5, 96, 58, 3, 45]
    for i in range(1, len(ls)):
        for j in range(0,len(ls)-i):
            if ls[j] > ls[j 1]:
                ls[j], ls[j 1] = ls[j 1], ls[j]
    print(ls)
    

        l1和l2指向的都以同二个内存地址,所以改善l1,l2也会改动。

    三.完成彩票36选7的成效. 从37个数中私行的发出7个数. 最后赢获得7个不重复的多寡作为最终的开奖结果.
    随机数:
    from random import randint
    randint(0, 20) # 0 - 20 的人身自由数

        2.浅copy

    from random import randint
    s = set()
    a = 1
    while int(len(s)) < 7:
        s.add(randint(1, 36))
    print(s)
    
    四. 税务部门征收所得税. 规定如下: 
            1). 收入在2000以下的. 免征.
            2). 收入在2000-4000的, 超过2000部分要征收3%的税. 
            3). 收入在4000-6000的, 超过4000部分要征收5%的税.
            4). 收入在6000-10000的, 超过6000部分要征收8%的税.  
            4). 收入在10000以上的, 超过部分征收20%的税. 
        注, 如果一个人的收入是8000, 那么他要交2000到4000的税加上4000到6000的税加上6000到8000的税. 
            收入 = 8000-(4000-2000)*3%-(6000-4000)*4%-(8000-6000)*8%
    让用户输入它的工资, 计算最终用户拿到手是多
    
    s = float(input('请输入你的工资:'))
    if s <= 2000:
        print("你最终的工资为:%s" % s)
    elif s > 2000 and s <= 4000:
        a = s - (s - 2000)*0.03
        print("你最终的工资为:%s" % a)
    elif s > 4000 and s <= 6000:
        a = s - (s - 4000)*0.05-(4000-2000)*0.03
        print("你最终的工资为:%s" % a)
    elif s >6000 and s <= 8000:
        a = s - (s - 6000)*0.08-(6000-4000)*0.05-(4000-2000)*0.03
        print("你最终的工资为:%s" % a)
    else:
        a = s - (s - 8000)*0.2-(8000-6000)*0.08-(6000-4000)*0.05-(4000-2000)*0.03
        print("你最终的工资为:%s" % a)
    

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

     

        l1.append('as')
        print(l1 is l2)    #终极为False,l1加上内容后,l1不等于l2

    2018-07-10  15:05:13

          

     “继续奔跑 输掉全部也决不输掉微笑” 

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

     

        l1[3].append('sa')
        print(l1[3] is l2[3])    结果为True,l1里的列表转换l2里的列表也随之调换。

        结论:浅copy第黄金年代层是不一样等的内部存款和储蓄器地址,不过第二层或越来越深层如故用的同二个内部存款和储蓄器地址。

        3.深copy

        为了缓慢解决浅copy难题,使用copy模块。

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

        l1[3].append('sa')
        print(l1 is l2)

        那样l1和l2的内部存款和储蓄器地址就全盘就不一致等了

    三、枚举

        可在列打印列表时加上对应的数字,近似1.alex 2.银角 3.漂亮的女子 4.egon 5.太白

        li = ['alex','银角','女神','egon','太白']    
        for index,name in enumerate(li,1):
        print(index,name)

     四、列表

        列表中最佳永不删除成分,删除后索引会发生变动。

        lis = [1,2,3,4,5]  #必要:用循环删除2,4    不可能正着删除,删除后索引会改进,能够倒着删除,或然用新列表替换。

         方法一:  

          for i in range(len(lis)-1,-1,-1):    #range(len(lis))  0,4    第多少个-1 从4上马,第4个-1 到-1实现,第二个-1  倒着输出
          if i % 2 != 0:
          del lis[i]
          print(lis)

         方法二:

          l = []
          for i in lis:
          if lis.index(i) % 2 ==0:
          l.append(i)
          lis = l
          print(lis)

    五、字典

        添加:

          dic = dict.fromkeys([1,2,3],'春哥')  
          print(dic)              #结果:{1: '春哥', 2: '春哥', 3: '春哥'}

          dic = dict.fromkeys([1,2,3],[])
          print(dic) # {1: [], 2: [], 3: []}
          dic[1].append('AS')
          print(dic)              #那多少个字典共用一个内部存款和储蓄器地址,改革三个都转移。

        删除:

          dic = {'k1':'v1','k2':'v2','a3':'v3'}  #去除键里富含k的键值对

          方法一:
            s = {}
            for i in dic:
            if 'k' not in i:
            s = {i,dic[i]}
            print(s)

          方法二: 

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

    六、元祖

        假诺元祖里面独有一个因素且不加,那此因素是哪些项目,正是哪些项目。

        tu1 = (1)
        tu2 = (1,)
        print(tu1,type(tu1),tu2,type(tu2))  #结果:1 <class 'int'> (1,) <class 'tuple'>

     

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:python全栈开荒,群集操作

    关键词: