您的位置:新葡亰496net > 奥门新萄京娱乐场 > 文件处理,编程语言与Python学习

文件处理,编程语言与Python学习

发布时间:2019-11-15 12:48编辑:奥门新萄京娱乐场浏览(157)

    风流倜傥、数字类型应用

    1.1 流程序调控制之for循环

    1 迭代式循环:for,语法如下 

    for i in range(10):
    
    
    
        缩进的代码块
    

     

     

    2 break与continue(同上)

    3 循环嵌套

    for i in range(1,10):
    
        for j in range(1,i 1):
    
            print('%s*%s=%s' %(i,j,i*j),end=' ')
    
        print()
    
    
    
    for else
    

     

     

    Python学习之路-Day2-Python幼功2,python-day2-python

    Python学习之路第二天

    读书内容

    1.模块初识

    2.pyc是什么

    3.python数据类型

    4.数量运算

    5.bytes/str之别

    6.列表

    7.元组

    8.字典

    9.字符串常用操作

     

    1.模块初识

    在头里脚本上是用 python 解释器来编制程序,假设你从 Python 解释器退出再步向,那么您定义的具有的措施和变量就都灭绝了。

    为此 Python 提供了叁个主意,把这么些概念贮存在文书中,为部分本子大概人机联作式的解释器实例使用,这些文件被叫作模块。

    模块是四个包涵全部你定义的函数和变量的文件,其后缀名是.py。模块能够被别的程序引入,以使用该模块中的函数等效用。这也是应用 python 典型库的法子。

    下边是三个施用 python 标准库中模块的例证。

     1 #!/usr/bin/python3
     2 # 文件名: using_sys.py
     3 
     4 import sys
     5 
     6 print('命令行参数如下:')
     7 for i in sys.argv:
     8    print(i)
     9 
    10 print('nnPython 路径为:', sys.path, 'n')
    

    实行结果如下所示:

    1 $ python using_sys.py 参数1 参数2
    2 命令行参数如下:
    3 using_sys.py
    4 参数1
    5 参数2
    6 
    7 
    8 Python 路径为: ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', 
    '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages'] 
    
    • 1、import sys 引进 python 标准库中的 sys.py 模块;这是引进某一模块的方法。
    • 2、sys.argv 是二个分包命令行参数的列表。
    • 3、sys.path 富含了一个 Python 解释器自动找出所需模块的门道的列表。

     

    可变与不可变类型

    • 可变:在值改变的场合,假设id不改变,注解就是在改进原值,就能够变类型
    • 不可变:在值改换的景况,假如id也随之变,表明根本未曾改动原值,即不可变类型

    1.2 开垦工具IDE

    import 语句

    想使用 Python 源文件,只需在另三个源文件里实施 import 语句,语法如下:

    import module1[, module2[,... moduleN]
    

    当解释器遭遇 import 语句,就算模块在眼下的搜寻路线就能够被导入。

    寻觅路线是一个解释器会先举行查找的全体目录的列表。如想要导入模块 ,必要把命令放在脚本的上边。

    开卷目录

    • ### 一、引子

    • ### 二、数字

    • ### 三、字符串

    • ### 四、列表

    • ### 五、元祖

    • ### 六、字典

    • ### 七、集合

    • ### 八、数据类型计算

    • ### 九、运算符

    • ### 十、字符编码

    • ### 十大器晚成、文件管理

    int基本选取

    1.2.1 为啥要用IDE

    到前天实现,大家也是写过代码的人啦,但您有未有觉察,每一回写代码要新建文件、写完保存时还要选择存放地点,实施时还要切换来命令行调用python解释器,好辛劳呀,能还是无法成功,让自家回顾的写代码?当时开采工具IDE登台啦,三个好的IDE能帮您大大晋级开荒功用。

    众多言语都有比较流行的开辟工具,举例JAVA 的Eclipse, C#,C 的VisualStudio, Python的是什么呢? Pycharm,最佳的Python 开垦IDE

    from…import 语句

    Python的from语句令你从模块中程导弹入二个点名的风流倜傥部分到眼下定名空间中,语法如下:

    from modname import name1[, name2[, ... nameN]]
    

    譬喻,要导入模块 fibo 的 fib 函数,使用如下语句:

    >>> from fibo import fib, fib2
    >>> fib(500)
    1 1 2 3 5 8 13 21 34 55 89 144 233 377
    

    那些宣称不会把全部fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引进进来。

     

    2.pyc是什么

    1. Python是一门解释型语言?

    自身初学Python时,听到的关于Python的首先句话正是,Python是一门解释性语言,笔者就这么一贯相信下去,直到发掘了*.pyc文件的存在。假如是解释型语言,那么生成的*.pyc文件是什么样呢?c应该是compiled的缩写才对啊!

    为了堤防别的学习Python的人也被那句话误解,那么大家就在文中来清淤下那个主题材料,并且把部分底工概念给理清。

      

    2. 解释型语言和编写翻译型语言 

    微处理器是不可以知道辨识高端语言的,所以当大家运营叁个高端语言程序的时候,就需求三个“翻译机”来从事把高端语言调换成电脑能读懂的机器语言的进程。这么些历程分成两类,第豆蔻年华种是编写翻译,第三种是解释。

    编写翻译型语言在程序实行以前,先会通过编写翻译器对程序实践一个编写翻译的经过,把程序调换成机器语言。运行时就无需翻译,而一向实践就可以了。最标准的例证便是C语言。

    解释型语言就不曾这么些编写翻译的长河,而是在程序运营的时候,通过解释器对程序逐行作出解释,然后径直运维,最优秀的事例是Ruby。

    透过以上的例子,大家可以来计算一下解释型语言和编写翻译型语言的优短处,因为编写翻译型语言在程序运营以前就已经对程序做出了“翻译”,所以在运转时就少掉了“翻译”的经过,所以功用相比较高。然而大家也不可能相提并论,一些解释型语言也得以通过解释器的优化来在对程序做出翻译时对全部程序做出优化,进而在效能上超越编写翻译型语言。

    除此以外,随着Java等借助设想机的言语的兴起,我们又不可能把语言纯粹地分为解释型和编译型那三种。

    用Java来比喻,Java首先是经过编写翻译器编写翻译成字节码文件,然后在运行时通过解释器给解释成机器文件。所以大家说Java是一种先编写翻译后解释的语言。

     

    3. Python到底是怎么着 

    其实Python和Java/C#相通,也是一门基于设想机的言语,大家先来从外表上粗略地打听一下Python程序的运维进程吧。

    当大家在命令行中输入python hello.py时,其实是激活了Python的“解释器”,告诉“解释器”:你要从头专门的学问了。不过在“解释”早先,其实施行的率先项职业和Java相符,是编写翻译。

    深谙Java的同班可以想转手大家在命令行中怎样实施叁个Java的次第:

    javac hello.java

    java hello

     

    只是大家在用Eclipse之类的IDE时,将这两部给融合成了生龙活虎部而已。其实Python也后生可畏致,当我们进行python hello.py时,他也同等实行了如此三个历程,所以我们应当这样来说述Python,Python是一门先编写翻译后解释的言语。

    4. 简述Python的运转进度

    在说这些难题早前,大家先来讲四个概念,PyCodeObject和pyc文件。

    咱俩在硬盘上观望的pyc自然不必多说,而事实上PyCodeObject则是Python编译器真正编写翻译成的结果。大家先轻易领悟就能够了,继续向下看。

    当python程序运转时,编写翻译的结果则是保存在位于内部存款和储蓄器中的PyCodeObject中,当Python程序运转停止时,Python解释器则将PyCodeObject写回到pyc文件中。

    当python程序第壹回运行时,首先程序会在硬盘中找找pyc文件,假如找到,则直接载入,不然就再也上边的长河。

    由此大家相应如此来定位PyCodeObject和pyc文件,大家说pyc文件其实是PyCodeObject的后生可畏种持久化保存方法。

     

    3.python数据类型

    1.数字

    Python 数字数据类型用于存款和储蓄数值。

    数据类型是不一样意改换的,那就表示风流倜傥旦改动数字数据类型得值,将重新分配内部存款和储蓄器空间。

    Python 帮衬两种分化的数值类型:

    • 整型(Int) - 平时被誉为是整型或整数,是正或负整数,不带小数点。Python3 整型是平素不范围大小的,能够用作 Long 类型使用,所以 Python3 未曾 Python2 的 Long 类型。
    • 浮点型(float) - 浮点型由整数有的与小数部分组成,浮点型也能够运用科学计数法表示(2.5e2 = 2.5 x 102 = 250)
    • 复数( (complex)) - 复数由实数部分和虚数部分组成,能够用a bj,恐怕complex(a,b)表示, 复数的实部a和虚部b都是浮点型。

    一、引子

    1 什么是数额?

      x=10,10是咱们要存款和储蓄的数额

    2 为什么数据要分分化的品类

      数据是用来代表情状的,不相同之处就应当用不一致的品种的数额去表示

    3 数据类型

      数字(整形,长整形,浮点型,复数)

      字符串

      字节串:在介绍字符编码时介绍字节bytes类型

      列表

      元组

      字典

      集合

    1.常用操作 内置方法

      算数运算,比较运算

    1.2.2 安装

    下载地址: 选择Professional 专业版 

    Comunnity社区版是免费的,但支撑的意义没多少,举例将来我们会学的Django就不扶植,所以照旧用职业版,但职业版是收取金钱的,一年意气风发千多,不实惠。唉,万能的天猫。。。不宜再多说啊。

     注册成功后运行,会让您先创建多少个品种,其实正是三个文书夹,大家随后的代码都留存这中间

     图片 1

     

    图1-1  

    Python 数字类型转变

    有时,大家供给对数据内置的体系实行转移,数据类型的转换,你只须求将数据类型作为函数名就能够。

    • int(x) 将x调换为一个板寸。

    • float(x) 将x转换成四个浮点数。

    • complex(x) 将x转产生二个复数,实数部分为 x,虚数部分为 0。

    • complex(x, y) 将 x 和 y 调换成三个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。

    以下实例将浮点数变量 a 转换为整数:

    >>> a = 1.0
    >>> int(a)
    1
    

    2.布尔值   真或假   1 或 0 3.字符串 字符串是 Python 中最常用的数据类型。我们能够运用引号('或")来创设字符串。 创设字符串很简短,只要为变量分配叁个值就可以。举个例子:

    var1 = 'Hello World!'
    var2 = "Runoob"
    

     

    4.多少运算

    算数运算:

    图片 2

    相比运算:

    图片 3

    赋值运算:

    图片 4

    逻辑运算:

    图片 5

    成员运算:

    图片 6

    身份运算:

    图片 7

    位运算:

     图片 8

    图片 9

     1 #!/usr/bin/python
     2   
     3 a = 60            # 60 = 0011 1100
     4 b = 13            # 13 = 0000 1101
     5 c = 0
     6   
     7 c = a & b;        # 12 = 0000 1100
     8 print "Line 1 - Value of c is ", c
     9   
    10 c = a | b;        # 61 = 0011 1101
    11 print "Line 2 - Value of c is ", c
    12   
    13 c = a ^ b;        # 49 = 0011 0001
    14 print "Line 3 - Value of c is ", c
    15   
    16 c = ~a;           # -61 = 1100 0011
    17 print "Line 4 - Value of c is ", c
    18   
    19 c = a << 2;       # 240 = 1111 0000
    20 print "Line 5 - Value of c is ", c
    21   
    22 c = a >> 2;       # 15 = 0000 1111
    23 print "Line 6 - Value of c is ", c
    

    View Code

    运算符优先级:

    图片 10

    微微电脑中能表示的小小单位,是多个二进制位

    Computer中能存款和储蓄的细小单位,是二个二进制位(bit卡塔尔国

    8bit = byte(字节)

    1024byte = 1Kbyte

    1024Kbyte = 1Mbyte

    1024Mb = 1Gb

    1024Gb= 1T

     

    5.bytes/str之别

     

    Python 3最主要的新特征差非常的少要算是对文件和二进制数据作了尤其明显的不一致。文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python 3不会以随机隐式的不二等秘书技混用str和bytes,正是那使得双方的区分极度清晰。你不能够拼接字符串和字节包,也回天乏术在字节包里找找字符串(反之亦然卡塔尔国,也不能够将字符串传入参数为字节包的函数(反之亦然卡塔尔。那是件好事

    无论怎么样,字符串和字节包之间的界限是确定的,上面包车型大巴图解超重大,务请牢记不忘记:

     

    图片 11

    字符串能够编码成字节包,而字节包能够解码成字符串。

    >>>'€20'.encode('utf-8')
    b'xe2x82xac20'
    >>> b'xe2x82xac20'.decode('utf-8')
    '€20'
    

    其一难题要如此来看:字符串是文件的充饥画饼意味。字符串由字符组成,字符则是与其余特定二进制表示非亲非故的悬空实体。在操作字符串时,大家生活在幸福的鸠拙之中。大家得以对字符串实行私分和分片,能够凑合和寻找字符串。咱们并不爱护它们之中是怎么表示的,字符串里的各类字符要用多少个字节保存。唯有在将字符串编码成字节包(比如,为了在信道上发送它们卡塔尔国或从字节包解码字符串(反向操作卡塔尔国时,大家才会伊始关切这一点。

    传扬encode和decode的参数是编码(或codec卡塔 尔(阿拉伯语:قطر‎。编码是生龙活虎种用二进制数据表示抽象字符的章程。近来有很两种编码。上边给出的UTF-8是中间风度翩翩种,上边是另风姿罗曼蒂克种:

    >>'€20'.encode('iso-8859-15')
    b'xa420'
    >>> b'xa420'.decode('iso-8859-15')
    '€20'
    

    编码是以此调换进程中要害的大器晚成局地。离了编码,bytes对象b'xa420'只是一批比特位而已。编码给予其含义。接受差异的编码,那堆比特位的意义就能够大区别:

    >>> b'xa420'.decode('windows-1255')
    '₪20'
    

     

    6.列表

    队列是Python中最基本的数据结构。类别中的每一个成分都分配叁个数字 - 它的岗位,或索引,第多个索引是0,第贰个目录是1,依此类推。

    Python有6个类别的放松权利类型,但最屡见不鲜的是列表和元组。

    队列都足以张开的操作包蕴索引,切成块,加,乘,检查成员。

    别的,Python已经停放分明系列的尺寸以至鲜明最大和纤维的成分的秘籍。

    列表是最常用的Python数据类型,它能够视作一个方括号内的逗号分隔值现身。

    列表的数量项不要求具有雷同的体系

    创办贰个列表,只要把逗号分隔的分化的多少项应用方括号括起来就可以。如下所示:

    list1 = ['Google', 'Runoob', 1997, 2000];
    list2 = [1, 2, 3, 4, 5 ];
    list3 = ["a", "b", "c", "d"];
    

    与字符串的目录同样,列表索引从0先河。列表能够进行截取、组合等。

    二、数字

    大背头与浮点数

    #整型int
      作用:年纪,等级,身份证号,qq号等整型数字相关
      定义:
        age=10 #本质age=int(10)
    
    #浮点型float
      作用:薪资,身高,体重,体质参数等浮点数相关
    
        salary=3000.3 #本质salary=float(3000.3)
    
    #二进制,十进制,八进制,十六进制
    
    #二:该类型总结
    1 存一个值or存多个值
        只能存一个值
    
    2 无序
    
    3 可变or不可变
        !!!不可变:值变,id就变。不可变==可hash
    
     
    

    任何数字类型(精晓卡塔 尔(阿拉伯语:قطر‎

    #长整形(了解)
        在python2中(python3中没有长整形的概念):      
        >>> num=2L
        >>> type(num)
        <type 'long'>
    
    #复数(了解)  
        >>> x=1-2j
        >>> x.real
        1.0
        >>> x.imag
        -2.0  
    

    2.该类型总括

    • 存三个值
    • 不得变类型
     x=10 print(id(x)) x=11 print(id(x)) 
    

    1.2.3 创设目录

    您之后写的品种恐怕有不胜枚举个代码文件 ,全放在一同可不好,所以通常把相近效果的代码放在贰个目录,大家以往以天为单位,为每一日的求学创立八个索引day1,day2,day3...这样

     图片 12

     

    图1-2  

    做客列表中的值

    行使下标索引来访问列表中的值,相通你也足以动用方括号的花样截取字符,如下所示

    #!/usr/bin/python3
    
    list1 = ['Google', 'Runoob', 1997, 2000];
    list2 = [1, 2, 3, 4, 5, 6, 7 ];
    
    print ("list1[0]: ", list1[0])
    print ("list2[1:5]: ", list2[1:5])
    

    上述实例输出结果:

    list1[0]:  Google
    list2[1:5]:  [2, 3, 4, 5]
    

    三、字符串

    #作用:名字,性别,国籍,地址等描述信息
    
    #定义:在单引号双引号三引号内,由一串字符组成
    name='egon'
    
    #二:该类型总结
    1 存一个值or存多个值
        只能存一个值2 可变or不可变
        !!!不可变:值变,id就变。不可变==可hash
    

     优先明白的操作:

    #1、按索引取值(正向取 反向取) :只能取
    msg='hello world'
    #第一位从0开始,最后一位是-1,倒数第二位是-2。
    print(msg[0],msg[-1]))
    h d
    
    #2、切片(顾头不顾尾,步长)
    print(msg[0:3]) #>=0 <3
    hel
    #不写代表从头开始,取到最后一位,如果写-1,最后一位取不到
    print(msg[:])
    hello world
    #设定步长为2,先取第一位,隔一位取一个;默认步长是1
    print(msg[0:7:2]) 
    hlow
    #反向取值,注意,顾头不顾尾,所以6能取到,而1不能
    print(msg[6:1:-1])
    w oll
    #将字符串反转
    print(msg[-1::-1])
    dlrow olleh
    
    #3、长度len
    print(len(msg))  #等同于,print(msg.__len__()),但是一般我们只用len()
    11
    
    #4、成员运算in和not in
    print('llo' in msg)
    True
    print('llo' not in msg)
    False
    
    #5、移除strip(两边开始,中间不管,默认可移除空格、n、t)
    password='    alex 3714     '
    print(password.strip())
    alex 3714
    #指定移除的字符
    password='***alex3714***'
    print(password.strip('*'))
    alex3714
    #从左边移除
    password='***alex3714***'
    print(password.lstrip('*'))
    alex3714***
    #从右边移除
    print(password.rstrip('*'))
    ***alex3714
    #与input连用
    password=input('>>: ').strip()
    
    #6、切分split,默认按空格切分,切分结果存在列表中
    user_info='root:x:0:0::/root:/bin/bash'
    res=user_info.split(':')
    print(res)
    ['root', 'x', '0', '0', '', '/root', '/bin/bash']
    #指定从左向右,切割几次,默认切到结束
    print(user_info.split(':',1))
    ['root', 'x:0:0::/root:/bin/bash']
    #从右向左,切割几次,注意列表顺序还是从左向右的。
    print(user_info.rsplit(':',1))
    ['root:x:0:0::/root', '/bin/bash']
    
    #7、循环,把字符串每个字符遍历输出
    msg='hel'
    for i in msg:
        print(i)
    h
    e
    l
    
    msg='hel'
    for i in range(len(msg)): #0 1 2
        print(i,msg[i])
    0 h
    1 e
    2 l
    
    #判断一个字符串是否为空
    len('') == 0
    

    字符串类型计算

    #二:该类型总结
    # 1 存一个值or存多个值
    #     只能存一个值
    
    # 2 有序
    
    # 3 可变or不可变
    #     !!!不可变:值变,id就变。不可变==可hash
    

     多变量赋值

    # Assign values directly
    a, b = 0, 1
    
    # Assign values from a list
    r,g,b =  ["Red","Green","Blue"]
    
    # Assign values from a tuple
    x,y = (1,2)
    

    图片 13图片 14

    #链式赋值
    a=b=c=2
    print(id(a),id(b),id(c))
    493143760 493143760 493143760
    
    #交叉赋值
    m=1
    n=2
    m,n=n,m
    print(m,n)
    
    #解压
    l=[1,2,3,4]
    a,b,c,d=l
    print(a,b,c,d)
    1 2 3 4
    
    #用_作为占位符
    l=[1,2,3,4]
    a,_,_,d=l
    print(a,d)
    
    #可以使用*_表示多个
    a,*_,d=l
    print(a,d)
    

    各类赋值

    range

    #renge(起始值,结束值,步长)
    #用于获取指定范围内的数。
    #在2.7中,使用range会创建所有数字,占用内存。xrange是默认不创建,只在for循环中,一个循环创建一个;3中range就等同于xrange,xrange也移除了。
    #默认从0开始,顾头不顾尾
    for i in range(3):
        print(i)
    0
    1
    2
    #指定开始值开始
    for i in range(1,3,1):
        print(i)
    1
    2
    #反向取值
    for i in range(3,1,-1)
        print(i)
    3
    2
    

    enumerate

    #enumerate(列表或元祖,指定起始值)
    #enumerate自动生成一列从0开始自增1的数字,通过for循环与列表或者元祖的每个元素组成新的元祖。
    
    li = ['电脑','鼠标','游艇','U盘']
    for key in enumerate(li):
        print(key)
    (0, '电脑')
    (1, '鼠标')
    (2, '游艇')
    (3, 'U盘')
    
    #enumerate(li,1)生成从1开始自增1的数,注意虽然1对应电脑,但是取值的索引还是0。
    li = ('电脑','鼠标','游艇','U盘')
    for x,y in enumerate(li,1):
        print(x,y)
    1 电脑
    2 鼠标
    3 游艇
    4 U盘
    

     供给调整的操作

    #1、partition,rpartition
    #指定分割符,将字符串分割成三部分,保存到元祖中,只分割一次
    msg='hello word'
    print(msg.partition('o'))
    ('hell', 'o', ' word')
    #从又向左找分隔符
    msg='hello word'
    print(msg.rpartition('o'))
    ('hello w', 'o', 'rd')
    
    #2、lower,upper
    #将字符串大写
    print('ALeX'.lower())
    #将字符串小写
    print('aaa'.upper())
    
    #3、startswith,endswith
    #0开始5结束是否以'a'开始
    msg='alex is SB'
    print(msg.startswith('a',0,5))
    True
    #字符串是否以B结尾
    print(msg.endswith('B'))
    
    #4、join
    #将元素都是字符串的列表或元祖的每个元素以指定字符串拼接(注意这是字符串的功能)
    li=['aa','bb','cc']
    print('_'.join(li))
    aa_bb_cc
    #如果元素中有数字,就会报错
    
    #5、replace
    #将前面的内容替换成后面的内容,指定替换几次,默认全部替换
    msg='alex say my name is alex ,alex have on tesla'
    print(msg.replace('alex','SB',1))
    SB say my name is alex ,alex have on tesla
    
    #6、isdigit
    #isdigit:可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
    age=input('>>: ')
    print(age.isdigit())
    

    别的操作(驾驭就可以卡塔尔

    #1、find,rfind,index,rindex,count
    #find找到字符串所在索引,不存在返回-1
    msg='hello world'
    print(msg.find('wo'))
    #rfind反方向开始找
    #index,rindex找索引,不存在报错
    print(msg.index('SB')) #ValueError: substring not found
    #count,统计有多少个。
    print(msg.count('l'))
    print(msg.count('l',0,5))  #指定范围
    
    #2、center,ljust,rjust,zfill
    #center,居中,其余地方默认用空格填充
    print('egon'.center(30,'*'))
    #ljust,左对齐
    print('egon'.ljust(30,'*'))
    #rjust,右对齐
    print('egon'.rjust(30,'*'))
    #zfill,居右,用0填充
    00000000000000000000000000egon
    
    #3、expandtabs
    #指定t为几个字符
    print('hellotworld'.expandtabs(10))
    hello     world
    
    #4、captalize,swapcase,title
    #captalize、将字符串首字母大写
    print('i am egon'.capitalize())
    I am egon
    #swapcase、大小写反转
    print('AbC'.swapcase())
    #title、将每个单词首字母大写
    print('i am egon'.title())
    
    #5、is数字系列(不能判断浮点数)
    num1=b'4' #bytes
    num2=u'4' #unicode,python3中无需加u就是unicode
    num3='壹' #中文数字
    num4='Ⅳ' #罗马数字
    isdigit()能识别:bytes,unicode的数字
    isdecimal()能识别:unicode的数字
    isnumeric()能识别:unicode,中文,罗马的数字
    
    #6、is其他
    # name='egon123'
    # print(name.isalnum()) #字符串由字母或数字组成
    # print(name.isalpha()) #字符串只由字母组成
    # print('abcA'.islower())#判断都是小写
    # print(name.isupper())#判断都是大写
    # print(' '.isspace())#判断是不是空格(不是空)
    # print('Am Ia'.istitle())#判断是不是标题
    #判断字符串是否是合法的标识符,字符串仅包含中文字符合法
    print('print1111'.isidentifier())
    #实际上这#里判断的是变量名是否合法。如:
    '_a'.isidentifier() -->True
    '3a'.isidentifier() -->False
    '中国'.isidentifier() -->True
    

    只顾:全部改正字符串的操作都以新兴成三个字符串,实际不是修复源字符串,因为字符串是不可变的。

    float基本使用

    1.2.4 成立代码文件

     图片 15

     

    图1-3  

    更新列表

    你能够对列表的数目项举行更换或更新,你也足以运用append()方法来增添列表项,如下所示:

    图片 16

    #!/usr/bin/python3
    
    list = ['Google', 'Runoob', 1997, 2000]
    
    print ("第三个元素为 : ", list[2])
    list[2] = 2001
    print ("更新后的第三个元素为 : ", list[2])
    

    View Code

    上述实例输出结果:

    第三个元素为 :  1997
    更新后的第三个元素为 :  2001
    

    四、列表

    #作用:多个装备,多个爱好,多门课程,多个女朋友等
    
    #定义:[]内可以有多个任意类型的值,逗号分隔
    my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
    或
    l=list('abc')
    

    刚开始阶段明白的操作:
    1、按索引存取值(正向存取 反向存取):就可以存也得以取 

    #取值与字符串操作一样
    #对其中元素从新赋值,就是改变原列表
    my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
    print(my_girl_friends[1])
    my_girl_friends[1]='bbb'
    print(my_girl_friends)
    
    wupeiqi
    ['alex', 'bbb', 'yuanhao', 4, 5]
    

    2、切成丝(顾前不管不顾后,步长)

    #与列表操作一致
    #ps:反向步长
    l=[1,2,3,4,5,6]
    
    #正向步长
    l[0:3:1] #[1, 2, 3]
    #反向步长
    l[2::-1] #[3, 2, 1]
    #列表翻转
    l[::-1] #[6, 5, 4, 3, 2, 1]
    

    3、长度len(成分个数卡塔尔

    #实际上也是在调用__len__()
    print(my_girl_friends.__len__())
    print(len(my_girl_friends))
    

    4、成员运算in和not in

    print('wupeiqi' in my_girl_friends)
    True
    

    5、追加append

    #列表不能通过定义新索引来追加,会报错
    my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
    my_girl_friends[5]=3 #IndexError: list assignment index out of range
    my_girl_friends.append(6)
    print(my_girl_friends)
    ['alex', 'wupeiqi', 'yuanhao', 4, 5, 6]
    

    6、删除del、remove、pop

    my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
    #1、单纯的删除、不能把删除的值赋给其他变量
    del my_girl_friends[0]
    print(my_girl_friends)
    ['wupeiqi', 'yuanhao', 4, 5]
    
    res=my_girl_friends.remove('yuanhao')
    print(my_girl_friends)
    print(res)
    ['alex', 'wupeiqi', 4, 5]
    None
    
    #2、删除并拿到结果:取走一个值,指定索引,不指定从最后一个开始
    res=my_girl_friends.pop(2)
    print(my_girl_friends)
    print(res)
    ['alex', 'wupeiqi', 4, 5]
    yuanhao
    
    my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
    print(my_girl_friends.pop(0)) #'alex'
    print(my_girl_friends.pop(0)) #'wupeqi'
    print(my_girl_friends.pop(0)) #'yuanhao'
    

    7、循环

    #每次循环得到一个元素
    my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
    for i in my_girl_friends:
        print(i)
    

    要精通的章程:

    1、插入insert

    my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
    my_girl_friends.insert(1,'egon')
    print(my_girl_friends)
    ['alex', 'egon', 'wupeiqi', 'yuanhao', 'yuanhao', 4, 5]
    

    2、清除clear

    my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
    my_girl_friends.clear()
    print(my_girl_friends)
    []
    

    3、统计count

    my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
    print(my_girl_friends.count('yuanhao'))
    2
    

    4、拷贝copy

    my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
    l=my_girl_friends.copy()
    print(l)
    ['alex', 'wupeiqi', 'yuanhao', 'yuanhao', 4, 5]
    

    5、扩展extend

    #append和insert都只能加入一个值,extend的可以添加多个
    #字符串、列表,元祖,字典等可for循环的,都可以被extend
    my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
    l=['egon1','egon2']
    my_girl_friends.extend(l)
    my_girl_friends.extend('hello')
    

    6、取索引index

    my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
    print(my_girl_friends.index('wupeiqi'))
    print(my_girl_friends.index('wupeiqissssss'))
    #不存在报错ValueError: 'wupeiqissssss' is not in list
    

    7、反转列表reverse

    my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
    my_girl_friends.reverse()
    print(my_girl_friends)
    [5, 4, 'yuanhao', 'yuanhao', 'wupeiqi', 'alex']
    

    8、列表排序sort

    #正向排序
    l=[1,10,4,11,2]
    l.sort()
    print(l)
    [1, 2, 4, 10, 11]
    
    #反向排序
    l.sort(reverse=True)
    print(l)
    [11, 10, 4, 2, 1]
    
    #注意:
    #字符串排序是从左向右一个一个比对,按照ascii的顺序比对
    #列表只能是纯数字或者纯字符串才能排序,否则报错
    
    #二:该类型总结
    # 1 存一个值or存多个值
    #     可以存多个值,值都可以是任意类型
    
    # 2 有序
    
    # 3 可变or不可变
    #     !!!可变:值变,id不变。可变==不可hash
    

    小心:全数改善列表的操作都是直接操作源列表的。

    1.常用操作 内置方法

      算法运算,相比较运算

    1.2.5 施行代码

     图片 17

     

    图1-4  

     

    除去列表成分

    能够动用 del 语句来删除列表的的要素,如下实例:

    图片 18

    #!/usr/bin/python3
    
    list = ['Google', 'Runoob', 1997, 2000]
    
    print (list)
    del list[2]
    print ("删除第三个元素 : ", list)
    

    View Code

    以上实例输出结果:

    删除第三个元素 :  ['Google', 'Runoob', 2000]
    

     五、元祖

    #作用:存多个值,对比列表来说,元组不可变(是可以当做字典的key的),主要是用来读,如果元祖元素是列表或者字典,则列表或字典的元素是可以变的。
    
    #定义:与列表类型比,只不过[]换成()
    age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))
    
    #优先掌握的操作:
    #1、按索引取值(正向取 反向取):只能取   
    #2、切片(顾头不顾尾,步长)
    #3、长度
    #4、成员运算in和not in
    #5、循环
    #与列表都一样
    

    必要明白的源委

    #1、查找索引 index
    age=(11,22,33,44,55)
    print(age.index(33))
    print(age.index(33333))  #不存在报错
    
    #2、统计count
    print(age.count(33))
    
    #二:该类型总结
    # 1 存一个值or存多个值
    #     可以存多个值,值都可以是任意类型
    
    # 2 有序
    
    # 3 可变or不可变
    #     !!!不可变:值变,id就变。不可变==可hash
    

    2.该项目总计

    • 存二个值
    • 不可变类型

     x=10.1 print(id(x)) x=11.1 print(id(x)) 

     

    1.3 数据

    Python列表截取与拼接

    Python的列表截取与字符串操作类型,如下所示:

    L=['Google', 'Runoob', 'Taobao']
    

    操作:

    图片 19

    >>> L=['Google', 'Runoob', 'Taobao']
    >>> L[2]
    'Taobao'
    >>> L[-2]
    'Runoob'
    >>> L[1:]
    ['Runoob', 'Taobao']
    >>> 
    

    列表还援救拼接操作:

    图片 20

    >>> squares = [1, 4, 9, 16, 25]
    >>> squares   [36, 49, 64, 81, 100]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    

    View Code

    六、字典

    #作用:存多个值,key-value存取,取值速度快
    
    #定义:key必须是不可变类型,value可以是任意类型
    info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
    或
    info=dict(name='egon',age=18,sex='male')
    或
    info=dict([['name','egon'],('age',18)])
    或 
    {}.fromkeys(('name','age','sex'),None)   #除了元祖还可以是列表,字符串等可迭代的数据,然后每个键都赋值为None,可以批量创建键值对
    

    优先明白的剧情

    #1、按key存取值:可存可取
    可通过赋值一个不存在的key,来增加新的键值对。
    d={'name':'egon'}
    print(d['name'])
    d['age']=18
    print(d)
    
    #2、长度len,键值对个数
    info={'name':'egon','age':18,'sex':'male'}
    print(len(info))
    3
    
    #3、成员运算in和not in,针对key的,而不是值value
    info={'name':'egon','age':18,'sex':'male'}
    print('name' in info)
    True
    print('egon' in info)
    False
    
    #4、删除
    #pop,移除指定键值对,并得到value
    info={'name':'egon','age':18,'sex':'male'}
    print(info.pop('name'))
    print(info)
    egon
    {'age': 18, 'sex': 'male'}
    #key不存在会报错,可指定不存在的key返回值而不报错。
    print(info.pop('name111',None))
    None
    
    #popitem,删除最后一个键值对(尽量当做无序的),得到键值对
    info={'name':'egon','age':18,'sex':'male'}
    print(info.popitem()) 
    ('sex', 'male')
    
    #5、键keys(),值values(),键值对items() #了解
    print(info.keys()) #打印所有键
    print(list(info.keys())[0]) #转换成列表取元素
    print(list(info.values())) #打印所有值
    print(list(info.items())) #打印所有键值对
    
    #6、循环
    #默认是对key进行循环
    info={'name':'egon','age':18,'sex':'male'}
    for k in info:
        print(k,info[k])
    for v in info.values():
        print(v)
    

    亟需精晓的内容

    #1、取值get
    info={'name':'egon','age':18,'sex':'male'}
    print(info['hobbies'])     #取不存在的key报错退出
    print(info.get('hobbies')) #使用get不会报错
    None
    print(info.get('hobbies','没有')) #指定返回值
    
    #2、update 、把一个字典加入另一个字典
    info={'name':'egon','age':18,'sex':'male'}
    d={'x':1,'y':2,'name':'EGON'}
    info.update(d)
    print(info)
    {'name': 'EGON', 'age': 18, 'sex': 'male', 'x': 1, 'y': 2}
    
    #3、setdefault,如果key存在,则不修改,返回已经有的key对应的value
    info={'name':'egon','age':16,'sex':'male'}
    value=info.setdefault('age',18) 
    print(value)
    print(info)
    16
    {'name': 'egon', 'age': 16, 'sex': 'male'}
    #如果key不存在,则新加一个键值对
    info={'name':'egon','age':16,'sex':'male'}
    hobbies_list=info.setdefault('hobbies',[])
    print(hobbies_list)
    hobbies_list.append('play')
    hobbies_list.append('read')
    print(info)
    []
    {'name': 'egon', 'age': 16, 'sex': 'male', 'hobbies': ['play', 'read']}
    
    #二:该类型总结
    # 1 存一个值or存多个值
    #     可以存多个值,值都可以是任意类型,key必须是不可变类型
    #
    # 2 无序
    
    # 3 可变or不可变
    #     !!!可变:值变,id不变。可变==不可hash
    

    二、字符串使用

    1.3.1 什么是数量?

      x=10,10是我们要存款和储蓄的数量

     

    嵌套列表

    行使嵌套列表即在列表里创立别的列表,举例:

    图片 21

    >>> a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'
    

    View Code

    PS:copy分为浅copy和深copy,更加的多的请点击上边包车型客车链接。

     

    7.元组

     

    元组其实跟列表大概,也是存风度翩翩组数,只不是它大器晚成旦创建,便无法再改正,所以又叫只读列表

     

    语法:

    names = ("alex","jack","eric")
    

    它只有2个方法,一个是count,一个是index。

     

     

    8.字典

    字典是另大器晚成种可变容器模型,且可存款和储蓄恣意等级次序对象。

    字典的每个键值(key=>value)对用冒号(:)分割,各类对中间用逗号(,)分割,整个字典满含在花括号({})中 ,格式如下所示:

    d = {key1 : value1, key2 : value2 }
    

    键必得是有一无二的,但值则不用。

    值能够取任何数据类型,但键必需是不可变的,如字符串,数字或元组。

    叁个简便的字典实例:

    dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
    

    也可这样创造字典:

    dict1 = { 'abc': 456 };
    dict2 = { 'abc': 123, 98.6: 37 };
    

    增加:

    图片 22

    >>> info["stu1104"] = "苍井空"
    >>> info
    {'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}
    

    View Code

    修改:

    图片 23

    >>> info['stu1101'] = "武藤兰"
    >>> info
    {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
    

    View Code

    删除:

    图片 24

    >>> info
    {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
    >>> info.pop("stu1101") #标准删除姿势
    '武藤兰'
    >>> info
    {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
    >>> del info['stu1103'] #换个姿势删除
    >>> info
    {'stu1102': 'LongZe Luola'}
    >>> 
    >>> 
    >>> 
    >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
    >>> info
    {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
    >>> info.popitem()
    ('stu1102', 'LongZe Luola')
    >>> info
    {'stu1103': 'XiaoZe Maliya'}
    

    View Code

    查找:

    图片 25

    >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
    >>> 
    >>> "stu1102" in info #标准用法
    True
    >>> info.get("stu1102")  #获取
    'LongZe Luola'
    >>> info["stu1102"] #同上,但是看下面
    'LongZe Luola'
    >>> info["stu1105"]  #如果一个key不存在,就报错,get不会,不存在只返回None
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 'stu1105'
    

    View Code

    练习:

    统计s='hello alex alex say hello sb sb'中每个单词的个数
    
    结果如:{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
    

    图片 26图片 27

    #利用setdefault解决重复赋值
    '''
    setdefault的功能
    1:key存在,则不赋值,key不存在则设置默认值
    2:key存在,返回的是key对应的已有的值,key不存在,返回的则是要设置的默认值
    d={}
    print(d.setdefault('a',1)) #返回1
    
    d={'a':2222}
    print(d.setdefault('a',1)) #返回2222
    '''
    s='hello alex alex say hello sb sb'
    dic={}
    words=s.split()
    for word in words: #word='alex'
        dic.setdefault(word,s.count(word))
        print(dic)
    

    View Code

    二、生龙活虎 str骨干使用

    1.3.2 为啥数据要分差别的档案的次序

      数据是用来代表景况的,差别的景色就活该用分裂的类型的数据去表示

    字典键的特点

    字典值能够未有范围地取任何python对象,既可以够是正规的对象,也得以是客户定义的,但键不行。

    多少个根本的点供给牢牢记住:

    1卡塔 尔(英语:State of Qatar)不容许同二个键现身五回。创造时只要同八个键被赋值一次,后三个值会被记住,如下实例:

    图片 28

    #!/usr/bin/python3
    
    dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
    
    print ("dict['Name']: ", dict['Name'])
    

    View Code

    以上实例输出结果:

    图片 29

    dict['Name']:  小菜鸟
    

    View Code

    2卡塔尔键必得不可变,所以能够用数字,字符串或元组充作,而用列表就那么些,如下实例:

    图片 30

    #!/usr/bin/python3
    
    dict = {['Name']: 'Runoob', 'Age': 7}
    
    print ("dict['Name']: ", dict['Name'])
    

    View Code

    如上实例输出结果:

    图片 31

    Traceback (most recent call last):
      File "test.py", line 3, in <module>
        dict = {['Name']: 'Runoob', 'Age': 7}
    TypeError: unhashable type: 'list'
    

    View Code

     

    9.字符串常用操作

    特点:不可改正

    name.capitalize()  首字母大写
    name.casefold()   大写全部变小写
    name.center(50,"-")  输出 '---------------------Alex Li----------------------'
    name.count('lex') 统计 lex出现次数
    name.encode()  将字符串编码成bytes格式
    name.endswith("Li")  判断字符串是否以 Li结尾
     "AlextLi".expandtabs(10) 输出'Alex      Li', 将t转换成多长的空格 
     name.find('A')  查找A,找到返回其索引, 找不到返回-1 
    
    format :
        >>> msg = "my name is {}, and age is {}"
        >>> msg.format("alex",22)
        'my name is alex, and age is 22'
        >>> msg = "my name is {1}, and age is {0}"
        >>> msg.format("alex",22)
        'my name is 22, and age is alex'
        >>> msg = "my name is {name}, and age is {age}"
        >>> msg.format(age=22,name="ale")
        'my name is ale, and age is 22'
    format_map
        >>> msg.format_map({'name':'alex','age':22})
        'my name is alex, and age is 22'
    
    
    msg.index('a')  返回a所在字符串的索引
    '9aA'.isalnum()   True
    
    '9'.isdigit() 是否整数
    name.isnumeric  
    name.isprintable
    name.isspace
    name.istitle
    name.isupper
     "|".join(['alex','jack','rain'])
    'alex|jack|rain'
    
    
    maketrans
        >>> intab = "aeiou"  #This is the string having actual characters. 
        >>> outtab = "12345" #This is the string having corresponding mapping character
        >>> trantab = str.maketrans(intab, outtab)
        >>> 
        >>> str = "this is string example....wow!!!"
        >>> str.translate(trantab)
        'th3s 3s str3ng 2x1mpl2....w4w!!!'
    
     msg.partition('is')   输出 ('my name ', 'is', ' {name}, and age is {age}') 
    
     >>> "alex li, chinese name is lijie".replace("li","LI",1)
         'alex LI, chinese name is lijie'
    
     msg.swapcase 大小写互换
    
    
     >>> msg.zfill(40)
    '00000my name is {name}, and age is {age}'
    
    
    
    >>> n4.ljust(40,"-")
    'Hello 2orld-----------------------------'
    >>> n4.rjust(40,"-")
    '-----------------------------Hello 2orld'
    
    
    >>> b="ddefdsdff_哈哈" 
    >>> b.isidentifier() #检测一段字符串可否被当作标志符,即是否符合变量命名规则
    True
    

     

    其次天学习总计:

    今后倍感学习python亦非那么的上火,最入眼的是协调能多去拜访外人的代码,多去练习就好。

    Python学习之路第二天 学习内容 : 1.模块初识 2.pyc是哪些 3.python数据类型 4.数据运算 5.bytes/st...

    七、集合

    #作用:去重,关系运算,
    
    #定义:
                可变类型是不可hash类型
    
    #定义集合:
                集合:可以包含多个元素,用逗号分割,
                集合的元素遵循三个原则:
                 1:每个元素必须是不可变类型(可hash,可作为字典的key)
                 2:没有重复的元素
                 3:无序
    
    注意集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值
    

    事先明白内容

    #优先掌握的操作:
    #1、定义集合:{}内用逗号分割每个元素都必须是不可变类型,元素不能重复,无序
    s={1,2,3,1} #s=set({1,2,3,1})
    
    #1、长度len
    print(len(s))
    
    #2、成员运算in和not in
    names={'egon','alex'}
    print('egon' in names)
    
    pythons={'egon','axx','ysb','wxx'}
    linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'}
    
    #3、|合集:老男孩所有的学生
    print(pythons | linuxs)
    print(pythons.union(linuxs))
    
    #4、&交集:同时报名两门课程的学生
    print(pythons & linuxs)
    print(pythons.intersection(linuxs))
    
    #5.1、-差集:只报名python课程的学生
    print(pythons - linuxs)
    print(pythons.difference(linuxs))
    
    #5.2、-差集:只报名linux课程的学生
    print(linuxs-pythons)
    print(linuxs.difference(pythons))
    
    #6、^对称差集:没有同时报名两门课程
    print(pythons ^ linuxs)
    print(pythons.symmetric_difference(linuxs))
    #7、==
    s1={1,2}
    s2={1,2}
    print(s1 == s2)
    True
    
    #8、父集:>,>= 
    print(s1 >= s2)
    print(s1.issuperset(s2))
    
    #9、子集:<,<=  
    print(s2 <= s1)
    print(s2.issubset(s1))
    
    #10、循环
    linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'}
    for student in linuxs:
        print(student)
    

    驾驭的知识点

    #1、pop随机取走
    s2={1,2,3,4,5,'a'}
    print(s2.pop())
    print(s2)
    1
    {2, 3, 4, 5, 'a'}
    
    #2、add添加
    s2={1,2,3,4,5,'a'}
    s2.add('b')
    print(s2)
    {1, 2, 3, 4, 5, 'a', 'b'}
    
    #3、删除
    #discard删除不存在的元素不报错
    s2={1,2,3,4,5,'a'}
    s2.discard('b')
    
    #remove删除不存在的元素报错
    s2={1,2,3,4,5,'a'}
    s2.remove('b')
    
    #4、isdisjoint两个集合没有共同部分时,返回值为True
    s1={1,2,3,4,5,'a'}
    s2={'b','c',}
    print(s1.isdisjoint(s2))
    True
    
    #5、把可迭代的数据转换成集合
    # l=['a','b',1,'a','a']
    # print(list(set(l)))
    # print(set('hello'))
    # print(set({'a':1,'b':2,'c':3}))
    
    #6、把差集从新赋值给集合
    s1={1,2,3}
    s2={1,2,}
    print(s1-s2)
    print(s1.difference(s2))
    s1.difference_update(s2) #s1=s1.difference(s2)
    print(s1)
    {3}
    {3}
    {3}
    
    二.去重
    
       1. 有列表l=['a','b',1,'a','a'],列表元素均为可hash类型,去重,得到新列表,且新列表无需保持列表原来的顺序
    
       2.在上题的基础上,保存列表原来的顺序
    
       3.去除文件中重复的行,肯定要保持文件内容的顺序不变
       4.有如下列表,列表元素为不可hash类型,去重,得到新列表,且新列表一定要保持列表原来的顺序
    
    l=[
        {'name':'egon','age':18,'sex':'male'},
        {'name':'alex','age':73,'sex':'male'},
        {'name':'egon','age':20,'sex':'female'},
        {'name':'egon','age':18,'sex':'male'},
        {'name':'egon','age':18,'sex':'male'},
    ]  
    

    图片 32图片 33

    #去重,无需保持原来的顺序
    l=['a','b',1,'a','a']
    print(set(l))
    
    #去重,并保持原来的顺序
    #方法一:不用集合
    l=[1,'a','b',1,'a']
    
    l1=[]
    for i in l:
        if i not in l1:
            l1.append(i)
    print(l1)
    #方法二:借助集合
    l1=[]
    s=set()
    for i in l:
        if i not in s:
            s.add(i)
            l1.append(i)
    
    print(l1)
    
    
    #同上方法二,去除文件中重复的行
    import os
    with open('db.txt','r',encoding='utf-8') as read_f,
            open('.db.txt.swap','w',encoding='utf-8') as write_f:
        s=set()
        for line in read_f:
            if line not in s:
                s.add(line)
                write_f.write(line)
    os.remove('db.txt')
    os.rename('.db.txt.swap','db.txt')
    
    #列表中元素为可变类型时,去重,并且保持原来顺序
    l=[
        {'name':'egon','age':18,'sex':'male'},
        {'name':'alex','age':73,'sex':'male'},
        {'name':'egon','age':20,'sex':'female'},
        {'name':'egon','age':18,'sex':'male'},
        {'name':'egon','age':18,'sex':'male'},
    ]
    # print(set(l)) #报错:unhashable type: 'dict'
    s=set()
    l1=[]
    for item in l:
        val=(item['name'],item['age'],item['sex'])
        if val not in s:
            s.add(val)
            l1.append(item)
    
    print(l1)
    
    
    
    
    
    
    #定义函数,既可以针对可以hash类型又可以针对不可hash类型
    def func(items,key=None):
        s=set()
        for item in items:
            val=item if key is None else key(item)
            if val not in s:
                s.add(val)
                yield item
    
    print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))
    

    View Code

    1.常用操作 内置方法

    1.1 按索引取值(正向取 反向取卡塔 尔(阿拉伯语:قطر‎:只好取   

    msg="hello world"
    print(msg[1])
    print(msg[5])
    print(msg[-1])
    print(msg[-3])
    

    1.2 切丝:从三个大字符串中切掉一个子字符串(顾前不管一二后,步长卡塔尔

    msg="hello world"
    print(msg[1:3])
    print(msg[6:11])
    print(msg[6:11:2]) #world #wrd
    
    # 倒着取值(了解):注意方向要一致
    print(msg[6:])
    print(msg[-1:-6:-1])
    print(msg[-1::-1])
    print(msg[::-1])
    

    1.3 长度len

     msg="hello world" print(len(msg)) # 长度是11,索引最大到10 

     

    1.4 成员运算in 和not in : 判别三个子字符串是还是不是存在于一个大字符串中

    msg="hello world hello momo"
    print('momo' in msg)
    print('world' in msg)
    print('hello' not in msg)
    print(not 'hello' in msg)
    

    1.5 移除空白strip

    msg='     mogu       '
    res=msg.strip() # 默认去除的是字符串左右两边的空格
    print(msg)
    print(res)
    
    # strip会从左往右开始吃空格,直到碰到一个非空格为止
    # 右面相同的原理
    #ps:strip并没有修改原值,是产生一个新值
    
    msg='******mo****gu*****'
    print(msg.strip('*'))
    
    msg='-&!^
    		

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:文件处理,编程语言与Python学习

    关键词:

上一篇:Python_note1

下一篇:没有了