Python初步学习

时间 2019-11-19

标签 python 初步学习栏目 Python 繁體版

原文原文链接

1、基本语法
一、标识符首字符必须是字母或者下划线_，其余部分由字母、数字或下划线_组成。
二、保留字以下：python

>>> import keyword
   >>> keyword.kwlist
   ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

三、单行注释使用#，多行注释使用'''或者"""。
四、代码块使用缩进来表示，而不是使用大括号{}，同一代码块的语句必须包含相同的缩进空格数。
五、多行语句使用反斜杠\来实现，在[],{}和()中多行语句不须要反斜杠。
六、多条语句同一行使用分号;分割。
七、导入模块使用import或者from...import。
   （1）将整个模块(somemodule)导入，格式为： import somemodule
   （2）从某个模块中导入某个函数,格式为： from somemodule import somefunction
（3）从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
   （4）将某个模块中的所有函数导入，格式为： from somemodule import *
八、每一个模块都有一个__name__属性，当其值是'__main__'时，代表该模块自身在运行，不然是被引入
九、序列解包（可迭代对象解包）是将一个序列解包，并将获得的值存储到一系列变量中。git

2、基本数据
一、变量不须要声明，但使用前都必须赋值。
二、六个标准数据类型：
   （1）Number（数字）：int、float、complex(复数)、bool
   （2）String（字符串）：（a）反斜杠能够用来转义，使用r可让反斜杠不发生转义
                                          （b）加号+是链接运算符，星号*是重复运算符
                                          （c）字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
                                          （d）字符串截取语法格式：变量[头下标:尾下标]
                                          （e）Python不支持单字符类型
                                          （f）原始字符串用前缀r表示，反斜杠结尾要加转义符
   （3）List（列表）：元素写在方括号[]里，之间用逗号分隔开，类型能够不一样
   （4）Tuple（元组）：（a）元素写在小括号()里，之间用逗号分隔开，类型能够不一样
                                      （b）元组可使用+号进行组合和*号进行复制，运算后会生成一个新的元组
   （5）Set（集合）：（a）元素写在花括号{}里，之间用逗号分隔开，无序不重复
                                  （b）可使用大括号 { } 或者 set() 函数建立集合，建立空集合必须用 set()
   （6）Dictionary（字典）：（a）字典是一种映射类型，用"{ }"标识，是一个无序的键(key) : 值(value)对集合
                                             （b）键(key)必须使用不可变类型且惟一
                                             （c）建立空字典用{}
   其中，（1）（2）（4）（5）数据不可变，（3）（6）数据可变。


3、运算符
一、算术运算符：+ - * / % **（幂） //（取整除）
二、比较运算符：== != > < >= <=
三、赋值运算符：= += -= += /= %/ **= //= （Python没有自增++和自减--）
四、位运算符：& | ^（按位异或） ~（按位取反） << >>
五、逻辑运算符：and or not
六、成员运算符：in not in
七、身份运算符：is is not（用于判断两个标识符是否引用自同一个对象，不要用于数和字符串等不可变的基本值）
                         is与==区别：is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。
               示例：正则表达式

>>>a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

4、经常使用数学函数
一、abs(x)              返回数字的绝对值，如abs(-10)返回10
二、ceil(x)              返回数字的上入整数，如math.ceil(4.1)返回5
三、exp(x)            返回e的x次幂(ex)，如math.exp(1)返回2.718281828459045
四、fabs(x)             返回数字的绝对值，如math.fabs(-10)返回10.0
五、floor(x)            返回数字的下舍整数，如math.floor(4.9)返回4
六、log(x)              返回对数，如math.log(math.e)返回1.0，math.log(100,10)返回2.0
七、log10(x)          返回以10为基数的x的对数，如math.log10(100)返回2.0
八、max(x1, x2,...) 返回给定参数的最大值，参数能够为序列
九、min(x1, x2,...)   返回给定参数的最小值，参数能够为序列
十、modf(x)       返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
十一、pow(x, y)       返回x**y 运算后的值
十二、round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则表明舍入到小数点后的位数
1三、sqrt(x)       返回数字x的平方根。express

5、经常使用字符串函数
一、capitalize()   将字符串的第一个字符转换为大写
二、count(str, beg= 0,end=len(string)) 返回str在string里面出现的次数，若是beg或者end指定则返回指定范围内str出现的次数
三、find(str, beg=0 end=len(string))   检测str是否包含在字符串中，若是指定范围beg和end，则检查是否包含在指定范围内，若是包含返回开始的索引值，不然返回-1
四、index(str, beg=0, end=len(string)) 跟find()方法同样，只不过若是str不在字符串中会报一个异常
五、expandtabs(tabsize=8)       把字符串string中的tab符号转为空格，tab符号默认的空格数是8
六、isalnum() 若是字符串至少有一个字符而且全部字符都是字母或数字则返回True，不然返回False
七、isalpha()   若是字符串至少有一个字符而且全部字符都是字母则返回True，不然返回False
八、isdigit()                            若是字符串只包含数字则返回True 不然返回False
九、isnumeric()                        若是字符串中只包含数字字符则返回True，不然返回False
十、len(string)                       返回字符串长度
十一、lower()                            转换字符串中全部大写字符为小写
十二、upper()                            转换字符串中全部小写字符为大写
1三、replace(str1, str2, max)   把将字符串中的str1替换成str2，若是max指定，则替换不超过max次
1四、split(str, num)                  以str为分隔符截取字符串，若是num有指定值，则仅截取num个子字符串json

6、经常使用列表函数
一、len(list)                      返回列表元素个数
二、max(list)                      返回列表元素最大值
三、min(list)               返回列表元素最小值
四、list(seq)                        将元组转换为列表
五、del list[i]                删除下标为i的元素
六、list.append(obj)          在列表末尾添加新的对象
七、list.extend(seq)           在列表末尾一次性追加另外一个序列中的多个值（用新列表扩展原来的列表）
八、list.count(obj)              统计某个元素在列表中出现的次数
九、list.index(obj)              从列表中找出某个值第一个匹配项的索引位置
十、list.insert(index, obj) 将对象插入列表
十一、list.pop([index=-1]]) 移除列表中的一个元素（默认最后一个元素），而且返回该元素的值
十二、list.remove(obj)         移除列表中某个值的第一个匹配项
1三、list.reverse()               反向列表中元素
1四、list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序
1五、list.clear()                  清空列表
1六、list.copy()            复制列表api

7、经常使用元组函数
一、len(tuple) 返回元组元素个数
二、max(tuple) 返回元组中元素最大值
三、min(tuple) 返回元组中元素最小值
四、tuple(seq) 将列表转换为元组数组

8、经常使用字典函数
一、len(dict)                         返回字典元素个数，即键的总数
二、str(dict)                                输出字典，以可打印的字符串表示
三、del dict['Name']                   删除键对应的元素
四、radiansdict.clear()                删除字典内全部元素
五、radiansdict.get(key, default=None) 返回指定键的值，若是值不在字典中返回default值
六、radiansdict.setdefault(key, default=None)   和get()相似, 但若是键不存在于字典中，将会添加键并将值设为default
七、radiansdict.items()               以列表返回可遍历的(键, 值)元组数组
八、radiansdict.keys()                 以列表返回一个字典全部的键
九、radiansdict.values()              以列表返回字典中的全部值
十、radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
十一、pop(key[,default])              删除字典给定键key所对应的值，返回值为被删除的值，key值必须给出，不然返回default值
十二、popitem()                           随机返回并删除字典中的一对键和值(通常删除末尾对)安全

9、条件控制
一、if语句：
   （1）关键字是if-elif-else
   （2）每一个条件后面要使用冒号:，表示接下来是知足条件后要执行的语句块
   （3）使用缩进来划分语句块，相同缩进数的语句在一块儿组成一个语句块
   （4）Python中没有switch–case语句多线程

10、循环控制
一、循环语句：
   （1）关键字是for和while
   （2）一样须要注意冒号和缩进
   （3）Python中没有do-while循环
二、break语句能够跳出for和while的循环体
三、continue语句能够跳过当前循环块中的剩余语句，而后继续进行下一轮循环
四、pass是空语句，不作任何事情，通常用作占位语句，是为了保持程序结构的完整性
五、内置函数zip用于并行迭代，可以使用list将返回值对象转换为由元组组成的列表，zip函数“缝合”以最短序列长度为准
六、内置函数enumerate用于索引-值对迭代，其中索引是自动提供的闭包

11、迭代器和生成器
一、迭代器：
   （1）迭代器是一个能够记住遍历位置的对象，迭代器对象从集合的第一个元素开始访问，直到全部的元素被访问完结束，只能往前不会后退
   （2）迭代器有两个基本的方法：iter() 和 next()
       示例：

>>>list=[1,2,3,4]
>>>it = iter(list)    # 建立迭代器对象
>>>print (next(it))   # 输出迭代器的下一个元素
1

   （3）字符串，列表或元组对象均可用于建立迭代器
二、生成器：
   （1）使用了 yield 的函数被称为生成器（generator）
   （2）生成器是一个返回迭代器的函数，只能用于迭代操做，更简单点理解生成器就是一个迭代器
   （3）在调用生成器运行的过程当中，每次遇到yield时函数会暂停并保存当前全部的运行信息，返回yield的值, 并在下一次执行next()方法时从当前位置继续运行


12、函数
一、简单规则：
   （1）函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()
   （2）任何传入参数和自变量必须放在圆括号中间，圆括号之间能够用于定义参数
   （3）函数的第一行语句能够选择性地使用文档字符串—用于存放函数说明
   （4）函数内容以冒号起始，而且缩进
   （5）return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return至关于返回 None
二、格式：def 函数名（参数列表）:
           函数体
三、不可变对象和可变对象：
   （1）numbers, strings, tuples和sets是不可变的对象，而list和dict等则是可变的对象
   （2）不可变对象在函数中修改了参数，原始参数并不改变
   （3）可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了
四、参数类型：
   （1）必须参数：必需参数须以正确的顺序传入函数，调用时的数量必须和声明时的同样
   （2）关键字参数：函数调用使用关键字参数来肯定传入的参数值，参数顺序能够与声明时不一致
   （3）默认参数：调用函数时，若是没有传递参数，则会使用默认参数
   （4）不定长参数：用于函数处理比当初声明时更多的参数，加了星号（*）的变量名会存放全部未命名的变量参数
五、匿名函数：
   （1）使用lambda来建立
   （2）lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
   （3）lambda函数拥有本身的命名空间，且不能访问本身参数列表以外或全局命名空间里的参数
   （4）格式：lambda [arg1 [,arg2,.....argn]]:expression
六、return [表达式]语句用于退出函数，选择性地向调用方返回一个表达式，不带参数值的return语句返回None
七、变量做用域：
   （1）L （Local）    局部做用域
   （2）E （Enclosing）闭包函数外的函数中
   （3）G （Global）     全局做用域
   （4）B （Built-in）    内建做用域
   （5）以 L –> E –> G –>B 的规则查找
   （6）只有模块（module），类（class）以及函数（def、lambda）才会引入新的做用域
       示例：

x = int(2.9) # 内建做用域
g_count = 0  # 全局做用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部做用域

八、全局变量和局部变量：
   （1）定义在函数内部的变量拥有局部做用域，局部变量只能在其被声明的函数内部访问
   （2）定义在函数外部的变量拥有全局做用域，全局变量能够在整个程序范围内访问
九、global和nonlocal关键字：
   （1）global修改全局变量
       示例：

num = 1
def func():
    global num  # global关键字声明
    num = 123
    print(num)

func()
print(num)

（2）nonlocal修改嵌套做用域（enclosing 做用域，外层非全局做用域）中的变量
示例：

def outer():
    num = 1

def inner():
    nonlocal num   # nonlocal关键字声明
    num = 123
    print(num)

inner()
print(num)
outer()

十3、遍历
一、在字典中遍历时，关键字和对应的值可使用items()方法同时解读出来
二、在序列中遍历时，索引位置和对应值可使用 enumerate()函数同时获得
三、同时遍历两个或更多的序列，可使用zip()组合
四、要反向遍历一个序列，调用reversed()函数
五、要顺序遍历一个序列，调用sorted()函数

十4、输入和输出
一、Python提供了input()内置函数从标准输入读入一行文本，默认的标准输入是键盘。
input能够接收一个Python表达式做为输入，并将运算结果返回。
二、Python两种输出值的方式: 表达式语句和print()函数
三、pickle模块实现了基本的数据序列和反序列化，基本接口pickle.dump(obj, file, [,protocol])

十5、文件读写
一、读写文件使用open()将会返回一个file对象，基本语法open(filename, mode)
二、打开文件模式：
   （1）r         以只读方式打开文件
   （2）rb       以二进制格式打开一个文件用于只读
   （3）r+      打开一个文件用于读写
   （4）rb+    以二进制格式打开一个文件用于读写
   （5）w       打开一个文件只用于写入
   （6）wb     以二进制格式打开一个文件用于写入
   （7）w+    打开一个文件用于读写
   （8）wb+ 以二进制格式打开一个文件用于读写
   （9）a       打开一个文件用于追加
   （10）ab   以二进制格式打开一个文件用于追加
   （11）a+   打开一个文件用于读写
   （12）ab+ 以二进制格式打开一个文件用于读写
三、操做文件方法：
   （1）f.read(size)         读取必定数目的数据, 而后做为字符串或字节对象返回
   （2）f.readline()         从文件中读取单独的一行，换行符为 '\n'。f.readline()若是返回一个空字符串, 说明已经已经读取到最后一行
   （3）f.readlines()       返回该文件中包含的全部行
   （4）f.next()               返回文件下一行
   （5）f.write(string)     将string写入到文件中，而后返回写入的字符数
   （6）f.tell()                 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数
   （7）f.seek(offset, from_what) 改变文件当前的位置，from_what的值0表示开头，1表示当前位置，2表示文件的结尾
   （8）f.close()              关闭文件并释放系统的资源

十6、异常处理
一、try-except处理异常
二、raise语句抛出一个指定的异常

十7、面向对象
一、类定义的语法格式以下：
   class ClassName:
       <statement-1>
       .
       .
       .
       <statement-N>
二、类对象支持两种操做：属性引用（obj.name）和实例化
三、类的方法必须有一个额外的第一个参数名称，按照惯例它的名称是self，self表明的是类的实例，是当前对象的地址，而self.class则指向类
四、派生类定义的语法格式以下：
   class DerivedClassName(BaseClassName1):
       <statement-1>
       .
       .
       .
       <statement-N>
五、python支持单继承和多继承，基类必须与派生类定义在一个做用域内
六、若是父类中有相同的方法名，而在子类使用时未指定，将调用最早继承的父类的方法
七、super()函数是用于子类已重写父类方法而调用父类(超类)的一个方法
八、两个下划线开头，声明该属性或方法为私有，不能在类地外部被使用或直接访问
九、类的专有方法：
   （1）__init__        构造函数，在生成对象时调用
   （2）__del__          析构函数，释放对象时使用
   （3）__repr__        打印，转换
   （4）__setitem__   按照索引赋值
   （5）__getitem__ 按照索引获取值
   （6）__len__          得到长度
   （7）__cmp__        比较运算
   （8）__call__         函数调用
   （9）__add__        加运算
   （10）__sub__    减运算
   （11）__mul__      乘运算
   （l2）__div__    除运算
   （13）__mod__    求余运算
   （14）__pow__     乘方

十8、正则表达式
一、re.match 尝试从字符串的起始位置匹配一个模式，若是不是起始位置匹配成功的话，match()就返回none
   函数语法：re.match(pattern, string, flags=0)
二、re.search 扫描整个字符串并返回第一个成功的匹配
   函数语法：re.search(pattern, string, flags=0)
三、re.findall 在字符串中找到正则表达式所匹配的全部子串，并返回一个列表，若是没有找到匹配的，则返回空列表
   函数语法：re.findall(string[, pos[, endpos]])
四、re.finditer 在字符串中找到正则表达式所匹配的全部子串，并把它们做为一个迭代器返回
   函数语法：re.finditer(pattern, string, flags=0)
五、re.sub 替换字符串中的匹配项
   函数语法：re.sub(pattern, repl, string, count=0)
六、re.compile 用于编译正则表达式，生成一个正则表达式（Pattern）对象，供match()和search()这两个函数使用
   函数语法：re.compile(pattern[, flags])
七、re.split 按照可以匹配的子串将字符串分割后返回列表
   函数语法：re.split(pattern, string[, maxsplit=0, flags=0])

十9、多线程
一、线程分为内核线程和用户线程。
二、Python3线程中经常使用的两个模块是_thread和threading。
三、线程使用的两种方式：
   （1）函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程
           语法：_thread.start_new_thread (function, args[, kwargs])
   （2）用类来包装线程对象。
四、Thread类方法
    （1）run()              用以表示线程活动的方法。
    （2）start()        启动线程活动。
    （3）join([time])    等待至线程停止。
    （4）isAlive()         返回线程是否活动的。
    （5）getName()     返回线程名。
    （6）setName()     设置线程名。
五、使用 Thread 对象的Lock和Rlock能够实现简单的线程同步，这两个对象都有acquire方法和release方法。
   示例：

threadLock.acquire()  # 获取锁，用于线程同步
print_time(self.name, self.counter, 3)       
threadLock.release()  # 释放锁，开启下一个线程

六、Queuem模块提供了同步的、线程安全的队列类，都实现了锁原语，可以直接在多线程中使用
    （1）FIFO（先入先出）队列Queue
   （2）LIFO（后入先出）队列LifoQueue
   （3）优先级队列PriorityQueue


二10、XML解析
一、Python有三种方法解析XML：
   （1）SAX    用事件驱动模型，经过在解析XML的过程当中触发事件并调用用户定义的回调函数来处理XML文件
   （2）DOM 将XML数据在内存中解析成一个树，经过对树的操做来操做XML
   （3）ElementTree

二11、JSON解析
一、Python3 中可使用json模块来对JSON数据进行编解码，它包含了两个函数：
   （1）json.dumps(): 对数据进行编码
   （2）json.loads(): 对数据进行解码

二12、日期和时间一、Python提供了一个time和calendar模块能够用于格式化日期和时间。二、time.time() 获取当前时间戳 time.localtime() 从返回浮点数的时间辍方式向时间元组转换 time.asctime() 获取可读的时间模式 time.strptime(format[, t]) 格式化日期