python学习

资源:
    1.[小甲鱼]零基础入门学习Python
        https://www.bilibili.com/video/av4050443/?from=search&seid=10660823011875778478
    2.基于资料1中视频的官网,鱼C论坛有很多资料
        http://bbs.fishc.com/forum-243-1.html
    3.字符串内置方法
        http://bbs.fishc.com/thread-38992-1-1.html
    4.Python及bs4、lxml、numpy模块包的安装
        http://blog.csdn.net/tiantiancsdn/article/details/51046490
    5.Python 关键字
        https://blog.csdn.net/liang19890820/article/details/68488392
    6.python内置函数大全
        https://www.cnblogs.com/pyyu/p/6702896.html


前言
    1.版本
        学习3.0,很多语法不兼容2.5
    2.安装
        下载3.6.4版本
        软件:Sublime Text 3 , python自带IDLE
    3.Bif 与 函数            

Sublime Text3 
    安装:略
    SublimeREPL插件: #可以直接输命令`
        安装:#http://blog.chinaunix.net/uid-12014716-id-4269991.html
        使用:#https://www.cnblogs.com/yshuangj/p/6404372.html


python IDLE快捷键
    Alt+N Alt+P 可以查找以前输入的命令用于补全当前命令


库的使用: #参考资料4
    1.使用pip安装,
        安装pip
            CMD到相应目录 : easy_install.exe pip


    2.库的安装
        from bs4 import BeautifulSoup
            #pip3 install beautifulsoup4
        from urllib import request      
            #python3自带
        lxml解析器
            #pip install lxml



学习:
    //参考资料1视频
    1.常用语法 与 基础
        print("jiuya"+" java")
        print("jiuya"*3)    
        print("jiuya\n"*3)  #换行
        缩进是python的灵魂,需要正确的使用缩进
        dir(__builtins__)  #查看python有多少内置函数bif,里面不是所有都是bif,纯小写的是
        help(input)  #查看input作用
        print('jiuya\'! java')   #字符串单引双引,需要转义
        str = r'D:\Java\tomcat'  #在字符串前加r 全部自动给字符转\变成\\
        str='''大大大            #三重引号可以自动给字段加\n
                大大大a
                dadavsxv'''
        if a==0:
            print('xxx')
        else:
            print('xxx')
        3>2 and 1<2   #逻辑操作符 and
        %d 只能输出整数,int类型
        %f 输出浮点数
        %s 输出string
        type() #查看数据类型
        isinstance(320,int) #判断数据类型,2参数:1.待确定参数,2.指定 , 返回True/False 

    2.引入模块
        random :randint() #random模块中randint()函数会返回一个随机整数
        import math     #引入数学模块

    3.python数据类型
        str , float , bool , int

    4.算数操作符
        + - * / % ** //     #    **冥运算     //float地板除法  去掉小数点后面的
            >>> a=10        
            >>> b=9.999
            >>> a//b
            1.0
            >>> a/b
            1.000100010001
            >>> b/a
            0.9999
            >>> b//a
            0.0

            >>>3**2  # 3*3
            9
    5.比较操作符
        < <= > >= != ==
    6.逻辑操作符
        and or not 
        并  或  非
            >>>not True 
            False
            >>>not 0
            True
            >>>not 4
            False
            >>>3 <4 <5
            True
    7.分支循环 #其它和java差不多
        if 条件:
            print()
        elif 条件:
            print()
        elif 条件:
            print()
        else:
            print()
    8.条件表达式(三元操作符)#2.5版本添加的
        small= x if x<y else y
    9.断言 assert 
        >>>assert 3>4 #当这个关键字后面条件为假,程序自动崩溃并抛出AssertionError的异常
    10.while循环
    11.for循环
        member = ['fafa','啊a啊','搜索','嗯嗯']
        for each in member:
            print(each,len(member))
    12.range()
        语法:range([strat,] stop[,step=1])
        #这个bif有三个参数,两个可选,step默认是1
            >>> range(5)
            range(0, 5)
            >>> list(range(5))
            [0, 1, 2, 3, 4]
            >>> for i in range(2,9):
                print(i)
            2
            3
            4
            5
            6
            7
            8
            >>> for i in range(1,10,2):
                print(i)    
            1
            3
            5
            7
            9
    13.列表[]
        普通列表,混合列表,空列表
        member = ['fafa','啊a啊',3.14,[1,2,3]]
        添加元素:
            member.append(4)  #追加
            member.extend([5,6])  #扩展
            member.insert(0,'法防')    
            member.remove('fafa')
            del member[1]    #del 是个语句不是方法
            member.pop()  #弹出;列表最后一个,弹出后列表没有该元素,可以有索引
                member.pop(1) #弹出索引值为1的元素
        列表分片:
            member[1:3]    #不包含3,不改变列表
            member[:3]
    14.列表上的常用操作符、    
        比较,逻辑,连接,重复,成员关系
         (list1 > list2) and (list1 == list3)
        >>>list1 = list1 + list3
        >>>list1 * 3 #复制三遍,不改变列表
        >>>list1 *= 3 #改变列表
        >>>123 in list1  #返回bool,判断1层列表
        >>>123 not in list1
        #list1 = [123,['aa','bb'],44]
        >>>'aa' in list1[1] 
    15.列表类型的内置函数
        dir(list) #列举 list内置函数
        list1.count(123) #计算123在list1中出现多少次
        list1.index(123) #找到第一个出现的位置
        list1.index(123,2,5) #指定范围
        list1.reverse() #翻转
        list1.sort() #排序 小到大
        list1.sort(reverse=True) #大到小
    16.元组:戴上枷锁的列表 tuple
        #元组与list使用上非常相识,不可以被修改
        创建和访问
            >>> tuple1=(1,2,3,4,5) 
            >>> tuple1[1]  
            2
            >>> tuple1[3:]  
            (4, 5)    
            #元组重点是, 不是()
            >>> tuple1=1,2,3    
            >>> tuple1=1,    
        更新和删除
            #以分片重组的方式
            >>> tuple1=(1,2,3,4,5) 
            >>> tuple1=tuple1[:2]+(3.5,)+tuple1[2:]
            (1,2,3,3.5,4,5) 
        元组相关操作符
            + 拼接操作符
            * 重复操作符
            in         成员操作符
            not in    成员操作符
    17.字符串内置方法
        #http://bbs.fishc.com/thread-38992-1-1.html
        切割
            >>> str='12345'
            >>> str[:3]
            '123'
        拼接
            >>> str1=str[:3]+'插入'+str[3:]
            >>> str
            '12345'
            >>> str1
            '123插入45'
        capitalize() #把字符串的第一个字符改为大写
            >>> str2='abcdef'
            >>> str2.capitalize()
            'Abcdef'
        casefold() #把整个字符串的所有字符改为小写
        center(width) #将字符串居中,并使用空格填充至长度 width 的新字符串
        count(sub[, start[, end]]) #返回 sub 在字符串里边出现的次数,start 和 end 参数表示范围,可选。
        encode(encoding='utf-8', errors='strict') #以 encoding 指定的编码格式对字符串进行编码。
        endswith(sub[, start[, end]]) #检查字符串是否以 sub 子字符串结束,如果是返回 True,否则返回 False。start 和 end 参数表示范围,可选。
        expandtabs([tabsize=8]) #把字符串中的 tab 符号(\t)转换为空格,如不指定参数,默认的空格数是 tabsize=8。
        find(sub[, start[, end]]) #检测 sub 是否包含在字符串中,如果有则返回索引值,否则返回 -1,start 和 end 参数表示范围,可选。
        index(sub[,start[,end]]) #与find差不多,如果sub不在字符串中会产生一个异常
        isalnum() #字符串至少有一个字符,字母数字都可以,有True 无false
        isalpha() #至少一个,只能是字符串 true  false
        isdigit() #只包含数字
        islower() #只能是小写
        replace(old, new[, count]) #把字符串中的 old 子字符串替换成 new 子字符串,如果 count 指定,则替换不超过 count 次。
        strip([chars]) #移除字符串头尾指定的字符(默认为空格)
        ....
    18.字符串格式化
        #Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
        >>>"{0} love {1}.{2}".format('I','rekoo','com')
        格式化符号:
            #http://www.runoob.com/python3/python3-string.html
              %c     格式化字符及其ASCII码
              %s     格式化字符串
              %d     格式化整数
              %u     格式化无符号整型
              %o     格式化无符号八进制数
              %x     格式化无符号十六进制数
              %X     格式化无符号十六进制数(大写)
              %f     格式化浮点数字,可指定小数点后的精度
              %e     用科学计数法格式化浮点数
              %E     作用同%e,用科学计数法格式化浮点数
              %g     %f和%e的简写
              %G     %f 和 %E 的简写
              %p     用十六进制数格式化变量的地址
            >>> '%c' %97 
            'a'
            >>> '%c%c%c' %(97,98,99)
            'abc'
        格式化操作符辅助指令:
            #http://www.runoob.com/python3/python3-string.html
            m.n.  #一般配合%f使用, m是总宽度,n是小数点后位数
        转义符号:
            ....
    19.序列
        #列表,元组,字符串
        Bif: #内置方法
            #help(list)
            list() #可迭代对象转list
            tuple()#可迭代对象转tuple
            len(sub)#返回长度
            max()#返回最大
            sum()
            sorted()
            zip()   # 打包为元组的列表
            reversed() #反转,是一个对象,需要list()
    20.函数        
        def MyFunction(name,word):
            print('ssss')
        属性:
            MyFunction.__doc__
        参数:
            关键字参数: 可以用在function 上也可以用在, 调用时

        内部/内嵌 函数:
            def fun1():
                print('fun1调用')
                def fun2():
                    print('fun2调用')
                fun2()
    21.闭包
        def funX(x):
            def funY(y):
                return x * y
            return funY
        使用闭包:
        >>>i=funX(8)
        >>>i(5)
        40
        >>>funX(8)(5)
        >>>40
    22.lambda 表达式    
        #创建函数,省下定义函数过程, 把函数变成一句话函数
        >>>t=lambda x:2*x
        >>>t(5)
        10
    23.递归
    24.字典 #dict   映射类型, K/V  
        字典是python唯一的映射类型 #不用索引时, 就可以用字典,
        #  http://www.runoob.com/python/python-dictionary.html
        s={'a':'A','b':'B','c':'C'}
    25.集合    #set
        s={'a','b','c'}
        s=set(['元组/列表/str'])
            1.具有唯一性, 
            2.无序
            3.不支持索引
        方法:
            v in set
            set.add(v)
               .remove(v)
        不可变集合:
            frozen:冰冻的
            frozenset([1,2,3,4])
    26.输入 输出 处理
        open() 函数用于打开一个文件,创建一个 file 对象
        # http://www.runoob.com/python/python-func-open.html
        open(name[, mode[, buffering]])
        打开模式:
            r只读(默认), w写 覆, a写 追加  
        方法:
            .close()
            .read(size=-1)
            .readline() #写入模式打开,文件存在,末尾追加
            .write(str) #将str写入文件


    00.Python关键字        
        global    定义全局变量 #可以把函数中局部变量变成全局函数
        nonlocal 与global使用是一样的 #细节自己百度吧
    00.内置函数:
        filter(function, iterable) #过滤器
            #>>>list(filter(lambda x:x%2,range(10)))  
            #[1,3,5,7,9]
        map(function, iterable, ...)     #遍历每个元素,执行function操作
            #>>> list(map(lambda x:x*2,range(10)))  把range生成的值, 放入前面函数得到加工后的值
            #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]



命令/关键字:
    scrapy:
        scrapy startproject XXXXX  //创建项目
        yield

    python:






问题:
    1.list的分片拷贝与直接赋值
        list1=list2[:]    #创建一个空间
        lisr1=list2     #使用同一个地址,只是多了一个指向
    2.list拼接
        list1=list1+list2
        list1=list1.extend(list2)
        #结果是一样的
    3.sort 与 sorted 区别:
        #http://www.runoob.com/python3/python3-func-sorted.html 
        sort是list的,但是sorted 可以对所有可迭代的对象进行排序操作。
        list1.sort()
        sorted(list1)
    4.在linux下编辑文件 
        缩进使用4个空格,linux类默认是空格,如果用Tab那就必须全换成Tab
    5.软链的使用    20180329设置python3软链时get
        ln -s /usr/local/python3/bin/python3 /usr/bin/python
        设置软连后,会创建一个文件, 如果错误了,需要删除在设置
    6.Python中的None
        # https://blog.csdn.net/baicaiye/article/details/72922197
    7.在闭包中return funX 与return funX() 是有区别的
        funX是返回函数,  funX()是执行函数   

数据类型

数据类型由三片段组成身份(id卡塔尔国、类型(type卡塔尔、值。
看对象有未有转移使用id(object)查看对象的内部存款和储蓄器地址是还是不是改造。

def compare(a,b):
  if a is b:  #a和b是同一个对象
    statements
  if a == b:  #a和b具有相同的值
    statements
  if type(a) =type(b):  #a和b具有相同的类型
    statements

python能一贯管理的数据类型有以下三种(type卡塔尔国
数值number:整数int,长整型long,浮点数float
#python3中long不设有,int能够积累六12位整数
布尔值bool:True、False
#只顾分寸写,在与数值运算时,True的值为1,False的值为0
空值:None
字符串:str
线性容器:list,tuple #扶植迭代,字符串也是意气风发种线性容器
Hash容器:dict,set

万一目的的值是足以修改的,则称之为可变对象(mutable卡塔尔国,不然成为不可变对象(immutable卡塔 尔(阿拉伯语:قطر‎。

能够扩充对象类型和值的对待。别的相比操作符也援救>、<、>=、<=、!=、==,逻辑操作符and、or、not

 

数值

翻开int对象所兼有的措施:help(int),dir(int),int.doc

bit_length(Number of bits necessary to represent self in
binary.重回表示该数字的时占用的最少位数卡塔 尔(阿拉伯语:قطر‎

a = 1
print a.bit_length()

资源:1.[小甲鱼]零基本功入门学习Python
关键字
Text 3 , python自带IDLE3.Bif 与 函数Sublime
Text3 安装:略SublimeREPL插件:
#能够一贯输命令`安装:#
python IDLE连忙键Alt+N Alt+P 能够寻觅以前输入的授命用于补全当前下令
库的运用: #参照他事他说加以考查资料41.应用pip安装,安装pipCMD到对应目录 :
easy_install.exe pip2.库的装置from bs4 import BeautifulSoup#pip3
install beautifulsoup4from urllib import request 
#python3自带lxml解析器#pip install lxml学习://参照他事他说加以考查资料1录制1.常用语法
与 底蕴print(“jiuya”+” java”)print(“jiuya”*3)print(“jiuya\n”*3) 
#换行缩进是python的神魄,须要科学的利用缩进dir(__builtins__) 
#查阅python有微微内置函数bif,里面不是装有都以bif,纯小写的是help(input) 
#查看input作用print(‘jiuya\’! java’)   #字符串单引双引,要求转义str =
r’D:\Java\tomcat’  #在字符串前加r
全部机关给字符转\变成\\str=”’大大大#三重引号能够自动给字段加\n大大大adadavsxv”’if
a==0:print(‘xxx’)else:print(‘xxx’)3>2 and 1<2   #逻辑操作符 and%d
只好输出整数,int类型%f 输出浮点数%s 输出stringtype()
#查阅数据类型isinstance(320,int)
#看清数据类型,2参数:1.待显著参数,2.钦定 ,
再次回到True/False 2.引进模块random :randint()
#random模块中randint()函数会再次回到一个随意整数import math   
 #引入数学模块3.python数据类型str , float , bool , int
4.算数操作符+ – * / % ** // #**冥运算 //float地板除法 
去掉小数点后边的>>> a=10>>> b=9.999>>>
a//b1.0>>> a/b1.000100010001>>> b/a0.9999>>>
b//a0.0>>>3**2  # 3*395.相比较操作符< <= > >= !=
==6.逻辑操作符and or not 并  或  非>>>not
True False>>>not 0True>>>not 4False>>>3 <4
<5True7.分支循环 #任何和java大约if 条件:print()elif
条件:print()elif
条件:print()else:print()8.条件说明式(莫斯利安操作符卡塔 尔(阿拉伯语:قطر‎#2.5版本增加的small=
x if x<y else y9.断言 assert >>>assert 3>4
#当那些至关心器重要字背后条件为假,程序自动崩溃并抛出AssertionError的不得了10.while循环11.for循环member
= [‘fafa’,’啊a啊’,’搜索’,’嗯嗯’]for each in
member:print(each,len(member))12.range()语法:range([strat,]
stop[,step=1])#其豆蔻梢头bif有七个参数,三个可选,step暗许是1>>>
range(5)range(0, 5)>>> list(range(5))[0, 1, 2, 3,
4]>>> for i in range(2,9):print(i)2345678>>> for i in
range(1,10,2):print(i)1357913.列表[]平日列表,混合列表,空驶列车表member =
[‘fafa’,’啊a啊’,3.14,[1,2,3]]添日币素:member.append(4) 
#追加member.extend([5,6]) 
#扩展member.insert(0,’法防’)member.remove(‘fafa’)del member[1]#del
是个语句不是艺术member.pop() 
#弹出;列表最终一个,弹出后列表未有该因素,能够有索引member.pop(1)
#弹出索引值为1的因素列表分片:member[1:3]#不包涵3,不更改列表member[:3]14.列表上的常用操作符、比较,逻辑,连接,重复,成员涉及
(list1 > list2) and (list1 == list3)>>>list1 = list1 +
list3>>>list1 * 3 #复制壹次,不转移列表>>>list1 *=
3 #改造列表>>>123 in list1 
#返回bool,判断1层列表>>>123 not in list1#list1 =
[123,[‘aa’,’bb’],44]>>>’aa’ in
list1[1] 15.列表类型的松开函数dir(list) #列举
list内置函数list1.count(123)
#计量123在list1中冒出些微次list1.index(123)
#找到第一个冒出之处list1.index(123,2,5) #钦赐范围list1.reverse()
#翻转list1.sort() #排序 小到大list1.sort(reverse=True)
#大到小16.元组:戴上紧箍咒的列表
tuple#元组与list使用上特别相识,不能被改变创设和拜见>>>
tuple1=(1,2,3,4,5) >>> tuple1[1]  2>>>
tuple1[3:]  (4, 5)#元组入眼是, 不是()>>>
tuple1=1,2,3>>>
tuple1=1,更新和删除#以半斤八两重新组合的方法>>>
tuple1=(1,2,3,4,5) >>>
tuple1=tuple1[:2]+(3.5,)+tuple1[2:](1,2,3,3.5,4,5) 元组相关操作符+
拼接操作符* 重复操作符in 成员操作符not
in成员操作符17.字符串内置方法#;
str=’12345′>>> str[:3]’123’拼接>>>
str1=str[:3]+’插入’+str[3:]>>> str’12345′>>>
str1’123插入45’capitalize() #把字符串的第叁个字符改为大写>>>
str2=’abcdef’>>> str2.capitalize()’Abcdef’casefold()
#把任何字符串的有着字符改为小写center(width)
#将字符串居中,并应用空格填充至长度 width 的新字符串count(sub[,
start[, end]]) #归来 sub 在字符串里边现身的次数,start 和 end
参数表示范围,可选。encode(encoding=’utf-8′, errors=’strict’) #以
encoding 钦命的编码格式对字符串举办编码。endswith(sub[, start[,
end]]) #检查字符串是还是不是以 sub 子字符串截止,若是是回来 True,不然再次来到False。start 和 end 参数表示范围,可选。expandtabs([tabsize=8])
#把字符串中的 tab 符号(\t卡塔尔转变为空格,如不钦命参数,暗中同意的空格数是
tabsize=8。find(sub[, start[, end]]) #检查评定 sub
是不是包罗在字符串中,假若有则再次来到索引值,不然再次来到 -1,start 和 end
参数表示范围,可选。index(sub[,start[,end]])
#与find大约,假如sub不在字符串中会产生叁个拾壹分isalnum()
#字符串至少有二个字符,字母数字都能够,有True 无falseisalpha()
#起码叁个,只可以是字符串 true  falseisdigit() #只含有数字islower()
#只好是小写replace(old, new[, count]) #把字符串中的 old
子字符串替换来 new 子字符串,如若 count 钦定,则替换不当先 count
次。strip([chars])
#移除字符串头尾钦赐的字符(暗许为空格卡塔 尔(阿拉伯语:قطر‎….18.字符串格式化#Python2.6
起头,新扩展了生机勃勃种格式化字符串的函数
str.format(),它巩固了字符串格式化的功力。>>>”{0} love
{1}.{2}”.format(‘I’,’rekoo’,’com’)格式化符号:# 
%c 格式化字符及其ASCII码  %s 格式化字符串  %d 格式化整数  %u
格式化无符号整型  %o 格式化无符号八进制数  %x 格式化无符号十二进制数  %X
格式化无符号十三进制数(大写卡塔尔国  %f 格式化浮点数字,可钦点小数点后的精度 
%e 用科学计数法格式化浮点数  %E 效用同%e,用正确计数法格式化浮点数  %g
%f和%e的简写  %G %f 和 %E 的简写  %p
用十七进制数格式化变量的地址>>> ‘%c’ %97 ‘a’>>>
‘%c%c%c’
%(97,98,99)’abc’格式化操作符支持指令:#. 
#貌似协作%f使用,
m是总幅度,n是小数点后位数转义符号:….19.类别#列表,元组,字符串Bif:
#嵌入方法#help(list)list()
#可迭代对象转listtuple()#可迭代对象转tuplelen(sub)#回来长度max()#再次来到最大sum()sorted()zip() 
 # 打包为元组的列表reversed() #反转,是叁个目的,须求list()20.函数def
MyFunction(name,word):print(‘ssss’)属性:MyFunction.__doc__参数:关键字参数:
能够用在function 上也足以用在, 调用时内部/内嵌 函数:def
fun1():print(‘fun1调用’)def fun2():print(‘fun2调用’)fun2()21.闭包def
funX(x):def funY(y):return x * yreturn
funY使用闭包:>>>i=funX(8)>>>i(5)40>>>funX(8)(5)>>>4022.lambda
表达式#创建函数,省下定义函数进程,
把函数变成一句话函数>>>t=lambda
x:2*x>>>t(5)1023.递归24.字典 #dict   映射类型,
K/V  字典是python唯风华正茂的映射类型 #毫无索引时, 就足以用字典,# 
, 2.严节3.不帮忙索引方法:v
in setset.add(v) 
 .remove(v)不可变会集:frozen:冰冻的frozenset([1,2,3,4])26.输入 输出
管理open() 函数用于张开一个文书,创建一个 file 对象#
, mode[,
buffering]])张开情势:r只读(默许), w写 覆, a写
追加  方法:.close().read(size=-1).readline()
#写入情势张开,文件存在,末尾追加.write(str) #将str写入文件
00.Python重大字global定义全局变量
#能够把函数中有的变量形成全局函数nonlocal 与global使用是雷同的
#细节自身百度吧00.放松权利函数:filter(function, iterable)
#过滤器#>>>list(filter(lambda
x:x%2,range(10)))  #[1,3,5,7,9]map(function, iterable, …)
#遍历各种成分,实践function操作#>>> list(map(lambda
x:x*2,range(10)))  把range生成的值, 归入前边函数得到加工后的值#[0, 2,
4, 6, 8, 10, 12, 14, 16, 18]命令/关键字:scrapy:scrapy startproject
XXXXX  //创设项目yieldpython:

二进制符号

  • 位移 >> <<
    x << y \ x >> y
    #左移(补0卡塔 尔(英语:State of Qatar)和右移(切尾卡塔 尔(英语:State of Qatar)是依照二进制的意气风发种算法 >>、
    <<,使用bin函数查看二进制
    x << y == x * ( 2 ** y )
    可用来总计硬盘体量,比如 1024 >> 10

  • 按位与 &
    二进制靠右对齐,不足补0,比较地点都以1则赶回1,别的位重临0
    可用于奇偶数推断,数值与1拓宽&运算,重临0则为偶数,重临1则为奇数:5 &
    1 == 1

  • 按位或 |
    二进制靠右对齐,不足补0,相比较地方只要有1,则赶回1

  • 按位异或 ^
    相比位相异再次来到1,相通再次来到0

  • 按位取反 ~

标题:1.list的分片拷贝与一向赋值list1=list2[:]#始建三个空间lisr1=list2 
 
 #运用同多少个地址,只是多了贰个照准2.list拼接list1=list1+list2list1=list1.extend(list2)#结果是平等的3.sort
与 sorted
差距:# sort是list的,不过sorted
能够对具有可迭代的靶子举办排序操作。list1.sort()sorted(list1)4.在linux下编写制定文件 缩进使用4个空格,linux类私下认可是空格,借使用Tab那就必得全换来Tab5.软链的应用20180329安装python3软链时getln
-s /usr/local/python3/bin/python3
/usr/bin/python设置软连后,会创设二个文书,
假如错误了,需求删除在装置6.Python中的None#

funX 与return funX() 是有分别的funX是回来函数,  funX()是实施函数   

字符串

python私下认可ascii码。使用单引号和双引号效果等同。
跟C语言相仿,能够接纳\进展转义:\n换行,\t制表符,\r回车符,\0空值(Null)

若是长字符串须要赶上来越多行,犹如下两种方法:

  • 动用”’xxxxxxxx”’替代普通引号
  • 应用五个”””xxxxxxxx”””
  • 在每行最后加上\将换行符转义。

原始字符串:借使在字符串前加上r,即出口引号中原始字符串 print r’let’s
go!’,不可能在原始字符串尾巴部分输入\,除非对其进展转义
字符串的目录:a[0],字符串偏移量从0从前,最后一人从-1开始。字符串的值不得原地改动。
+为字符串的拼接,*为字符串的再度

查看字符串具有的法子:help(str),dir(str)
count(self, sub, start=None,
end=None):用于总括字符串里有个别字符现身的次数,可选参数为在字符串找出的开始与甘休地方。sub
–> 找出的子字符串,start –>
字符串最初找寻的任务。默以为首先个字符,第八个字符索引值为0。end –>
字符串中得了搜索之处。字符中第叁个字符的目录为
0。默感到字符串的终极二个岗位。
decode(self, encoding=None,
errors=None):解码,对于len在拍卖汉字的时候因为重临的是字节数目引致结果不符,能够动用decode转码,可能len(u”哈哈”)
encode(self, encoding=None, errors=None):编码,针对unicode
find(self, sub, start=None,
end=None):检查评定字符串中是否含有子字符串str,倘使钦定beg(开端)和end(停止)范围,则检查是或不是带有在钦定范围内,如若含有子字符串重返起首的索引值,不然重回-1。
isalnum(self):法检查实验字符串是或不是由字母和数字组成,假使string至稀有八个字符何况具备字符都以字母或数字则赶回True,不然重返False
isalpha(self):
split: S.split([sep [,maxsplit]]) -> list of
strings重临一个list
join:
replace:
translate:
示范:打印出字符串中的字符及其位置

a = 'shsh'
for i in range(len(a)):
    print '(%d)' % i,a[i]

也能够采取enumerate()函数:

a = 'shsh'
for i,ch in enumerate(a):
      print '(%d)' % i,ch

演示:抽出字符串中的数字

a = "aAsmr3idd4bgs7Dlsf9eAF"
print ''.join([x for x in a if x.isdigit()])

亲自去做:字符串的拼凑
1.c = a + b
2.c = “{a}{b}” .format(a=a,b=b)
3.c = “%s%s” % (a,b)
4.c=””.join([a,b])

str和repr

str函数用于将值转变为适用于人观看的花样,也正是to string
repr函数转变为供解释器读取的样式,创设八个合法的字符串表示值,repr(x)同风度翩翩x
print ‘1+2=’+1+2

字符串格式化format

在Python中,选拔的格式化方式和C语言是千篇意气风发律的,用%达成;
有多少个%?,后面就跟多少个变量,顺序须要生龙活虎致(唯有三个变量的时候,括号能够大致卡塔尔;若是不太承认用怎么样,能够直接动用%s将其余数据类型转变为字符串;
字符串里含%可用%%举行转义,来代表三个%;
能够在”%”和字母之间插进数字代表最大场宽。 举个例子: %3d 表示输出3位整型数,
非常不足3位右对齐。 %9.2f 表示输出场宽为9的浮点数, 在那之中型Mini数位为2, 整数位为6,
小数点占一位, 相当不够9位右对齐。
%d 整数 :print “1+1 = %d ” % int(1+1)
%f 浮点数
%s 字符串 : print “my name is %s lilei” % “hanmeimei’s”
%x 十五进制整数
‘%s is a %s’ % (‘he’,’boy’)
字典情势的字符串的格式化越来越灵敏,注意花括号之处

‘%(who)s is a %(gender)s’ %{‘who’:’he’,’gender’:’boy’}
“this is {whose} {fruit}” .format (fruit = “apple” , whose = “my”)

list 列表

方括号中,逗号分隔,索引下标从0开始。类型可变,成分的类型能够差别,能够分包自由等级次序的python对象。帮助嵌套,list里也足以包蕴三个list。可原地改过内容。

创建三个空驶列车表:
names = []
names = list()

以不改变应万变集中
classmate = [‘Micherl’,’Bob’,’Marry’]
len(classmate),max(classmate),min(classmate)
classmate[0] classmate[-1] #取值
classmate[1]=’Kack’
#赋值,不能够赋值当先列表长度,能够先举行开端化,再开展赋值
del classmate[1] #除去成分,前边成分前移
‘Marry’ in classmate #in or not in判别成分是还是不是在列表中
classmate.index(‘Micherl’)
运用+运算符能够接连列表

列表的艺术

classmate.append(‘Adam’) #扩展,重回值实际不是新的list,而是none
classmate.count(‘Bob’) #某成分现身次数
classmate1.extend(classmate2) #将b扩充到a后边,a的列表刷新了
classmate.index(‘Bob’) #值追索引
classmate.insert(1,’Jack’) #1至前边的要素集体后移,插队
classmate.pop(1) #脱离最后二个要素,与append雷同栈,后进先出
classmate.remove(‘Bob’) #剔除第二个相称成分
classmate.reverse #要素反向
sort方法:
x=[1,3,2,6,4]
y=x[:]
#不能够大约的y=x.sort()因为sort方法无再次来到值,也足以运用sorted(x),能够再次回到排序后的列表
y.sort()
print x
print y

分片

classmate[1:2]
第三个索引包含在分片内,第一个索引不带有在分片内,日常第两个参数默以为1,步长假如为负数,则从右到左提取成分。
分片赋值 classmate[2:]=’a’ 也等于替换到分
分片删除 del classmate[2:]
列表能够进行相加 print
[1,2,3]+[3,4],相仿类别技艺拓宽相加,如列表和字符串无法拓宽加减
乘法:系列乘以数值,则连串会被再次数值次数,
空值 None 假诺要初叶化二个尺寸为10的空系列 seq=[None]*10
反省三个值是或不是在系列中 ‘Micherl’ in classmate 重回布尔值

列表、元组和字典字面量能够在不选择续行符()的气象下分步多行,此外最后豆蔻年华项允许跟一个逗号

a = [1,
3,4,
  "hello",
]

列表深复制和浅复制

浅复制:

a=[1,2,[3,4]]
b=a
b is a #b和a指向同一个对象
del b  
print a  #删除b后,既删除b的指向,a无变化
print b
b=list(a)  #创建一个a的浅复制
b is a   #False
b.append(100)  #给b追加一个元素
print a    #a无变化
print b    #b增加了一个元素
b[2][0]=-100
print a
print b #注意a的变化
c=a
del c[:]
print a
print c

深复制将开创二个新的指标,并且递归复制它所包含的享有目的

import copy
a = [1,2,[3,4]]
b = copy.deepcopy(a)
b[2][0] = -100
print a
print b

列表推导式

[expr for iter_var in iterable]
:首先迭代iterable里全体的内容,每叁次迭代都把iterable中的内容放到iter_var中,再在表达式中央银行使该iter_var的内容,最终用表明式总结值生成三个列表。
[x+1 for x in range(1:11)]
能够那样敞亮那些推导式
new_list=[]
for x in range(1:11)
new_list.append(x+1)
print new_list

[expr for iter_var in iterable if cond_expr]
:出席了剖断语句,唯有满意cond_expr条件的才把iterable丢到iter_var,最终用表达式生成列表
[x+1 for x in range(1:11) if x % 2 == 1]
生成字符串:[‘the %s’ % d for d in xrange(10)]
生成元组:[(x,y) for x in range(2) for y in range(2)]
转移字典:dict([(x,y) for x in range(3) for y in range(3)])
g = {i:j.upper() for i,j in zip(range(1,6),’abcde’)}

zip函数

zip(s,t卡塔尔函数将列表s和列表t组成叁个元组列表(s[0],t[0])、(s[1].t[1])等,假如s和t长度不等,则以短的尺寸停止。

zip函数在python第22中学会完全创造多少个元组列表,函数itertools.izip二遍只生成多少个元组,质量较好

xrange and range

range:间接生成二个列表对象
xrange:生成三个xrange对象。当要求扭转十分大的数目,内存比较恐慌,xrange比较省外部存储器。xrange通常用在循环之中,举例只必要操作部分数据,实际不是回来全体成分来形成操作的景色
for m in range(1000): #一遍性生成1000个数字
if m == 10:
print “ss”
break
for m in xrange(1000): #只生成10个数字
if m == 10:
print “ss”
break
在python3种xrange(卡塔尔函数已经更名称为range(卡塔尔,而且意气风发度删除了老式range(卡塔尔函数的法力。

tuple 元组

假若开头化就无法改革,括号,逗号分隔。无法原地订正,不能够排序。

classmates = (‘Michael’, ‘Bob’, ‘Tracy’)
tuple的骗局:当您定义二个tuple时,在概念的时候,tuple的因素就必需被分明下来,
唯有1个要素的tuple定义时必需加三个逗号,防止歧义(以下二种办法都可以)

t = (1,)
t = 1,    #即使没有圆括号,python也可以识别出元组

以下示例看起来元组被修正了,查看id发掘元组对象已经被改动了
a = (1,2)
b = list(a)
type(b)
b[0] = 5
a = tuple(b)
print a
type(a)

dict 字典

花括号,逗号分隔,key和value使用冒号分隔,key唯风姿罗曼蒂克,value不一定唯后生可畏.冬辰,不能够通过偏移取值。可变类型,可嵌套。

创设二个空字典
d = {}
d = dict()
组成字典的键必得是不可变的数据类型,举个例子数字、字符串、元组等,列表等可变类型不可作为键
d = {‘Michael’: 95,’Bob’: 75, ‘Tracy’: 85} #创造字典
d[‘Michael’]
d[‘Adam’] = 67 #增增加少也许更新数据
del d[‘Michael’] #删除字典成分
‘Thomas’ in d #判定是或不是存在KEY d.has_key(‘Thomas’)

字典的措施

d.clear() #清空
d.get(‘Thomas’)
d.get(‘Thomas’, -1) #万一荒诞不经托马斯则赶回-1
d.pop(‘Bob’) #删去一个Key,对应的value也删除
d.update({‘Michael’: 99})
d.keys() #再次来到键的列表 等同于list(d)
d.values() #再次回到值的列表
d.items() #变迁叁个字典的器皿 [()]

dict函数

items=[(‘name’,’grb’),(‘age’,42)]
d=dict(items) #也许通过机要字创制 d=dict(name=’grb’,age=42)
print d

set 集合

set和dict相似,也是黄金年代组key的集中,但不存款和储蓄value。由于key无法重新,所以,在set中,未有重新的key。未有各样的定义,所以不可能切丝和目录操作。
t = set(“hello”) #始建多个独一字符的会集
t
s = set([1, 2, 3])
s
s.add(4) #增加风流浪漫项
s.update([7,8,9,10]) #添扩张项
s.remove(4) #剔除意气风发项
成员操作关系 in 、not in
掺杂( & )、并集( | )、差集( – )、对称差集(^)
a = t | s
b = t & s
c = t – s
d = t ^ s #t和s中,但分化是在t和s中
判断集结是不是等于与各类非亲非故 print set(‘abc’) == set(‘bac’)
列表的去重:
a = [1,2,3,3,4,4,5]
b=list(set(a))

frozenset()不可变集结

相关文章