Python3学习笔记

脚本式编程

在Linux/Unix系统中，你可以在脚本的顶部添加以下命令让Python脚本可以像SHELL脚本一样执行：

#! /usr/local/bin python3
//代码

由于脚本依赖电脑上的Python环境，而不同的电脑上的Python环境是有差异的。以Mac OS来说，一般情况下Mac是自带python2环境的在/usr/bin目录下，Python3默认是没有安装的，同时Python3和Python2是不兼容的，所以你的脚本如果是用Python3编写，你的脚本头要写你本地Python3环境的可执行路径。

如果你的Python3环境是用 Home brew安装的对应的路径就是/usr/local/bin

运算符

相对于Java语言Python的运算符有以下需要注意的地方：

1.数字运算符

运算符	描述	实例
**	幂运算符	a**b 为a的b次方
//	取整除	4//3 = 1
in	在指定的序列中True	1 in （1, 3）== True

2.字符串运算符

定义如下字符串a = "Hello"; b = "Python"

运算符	描述	实例
+	字符串连接	a + b 结果：HelloPython
*	重复输出字符串	a*2 结果：HelloHello
[]	通过索引访问字符串中的字符	a[1] 结果：e
[:]	截取字符串的一部分，遵循左闭右开的原则	a[1:3] 结果：ela[-3:] 结果：llo
r/R	原始字符串	print(r"\n")结果：\nprint("\n")结果：换行

变量

变量的定义不需要声明类型，Python可以自动完成类型的推断，使用del语句可以删除一个或多个对象的引用，被删除的变量继续访问会报NameError。

var1 = 1
var2 = 10
del var1, var2

nums = [1, 2, 3, 4]
del nums[2] 

原组

Python原组与列表相似使用圆括号(定义，不同之处是原组的元素不能删除、增加、修改。

*字符串是一种特殊的元组。*

tup1 = (2, 3, 4, 5)
print(tup1[1:3]) // 2,3

字典

Python字典格式类似JSONObject，键值对使用:分隔，格式如下：

d = {"Alice": 2, "Jim": 4}
key = "Alice"
print(key, "age:", d[key])

集合

集合（Set）是一个无序不重复的元素序列。可以使用{}和set()函数创建集合。注意⚠️：创建一个空集合必须使用set()而不是{}，因为{}是用来创建一个空字典。集合的更改不能使用运算符，而要使用集合对象提供的方法。

1. 增加：add()
2. 删除：remote()
3. 计算元素个数：len(set1)
4. 清空：set1.clear()

set1 = {"Jim", "Tom", "Alice"}
set2 = set()
set1.add("W")
print(set1)

条件控制

相对于Java的else if Python 使用elif，格式如下：

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

循环语句

Python中的循环语句支持和else结合使用，例如：

count = 0
list1 = range(6)
while count < 3:
    pass
    print("while", list1[count])
    count += 1
else:
    print("else")

注意：

• pass 占位语句
• range()函数生成序列

函数

Python使用def定义函数，Kotlin使用fun，Swift使用func。格式如下：

def 函数名（参数列表）:
    函数体

实例：

def area(w, h=1):
    return w * h

m = area(2, 3)
print(m)

#不定参数定义方法 -- *
def sums(arg, *args):
    for var in args:
        arg += var
    return arg

s = sums(1, 2, 3, 4)
print(s)

#使用 -- **
def show(arg, **args):
    print(arg, args)

print(show(1, a=1, b=2))

总结：

• 函数参数支持默认值
• 调用的时候如果指定参数的名称可以打乱参数顺序
• 使用*定义函数的不定参数，加了*的参数会以元组（tuple）的形式传入
• 使用**定义的参数，使用字典的形式传入

Python使用lambda来创建匿名函数，语法格式如下：

lambda [arg1 [,arg2,.....argn]]:expression

像上面的sums函数可以使用lambda实现等效的定义

sums = lambda a, b: a + b

作用域

Python中有4种作用域分别是：

1. Local（L） 局部作用域
2. Enclosing（E） 闭包函数外的函数中
3. Global（G） 全局作用域
4. Build-in（B） 内建作用域

查找顺序 L > E > G > E，当内部作用域想修改外部作用域的变量的时候需要用到global和nonlocal关键字：

• global L 修改G
• nonlocal L 修改 E

模块

在Python中一个Python文件叫做一个模块（这有一点类似Kotlin区别于Java），使用import关键字导入模块。同一个模块只会被导入一次，多次执行无效。被导入的模块会首先在当前目录下搜索如果没有找到就会从环境变量（sys.path）的目录中搜索，在你安装拆卸模块的时候sys.path会跟着更新。

import sys

print(sys.path)

不想导入整个模块你也可以使用from ... import语句导入部分功能，语法如下：

from sys import path

print(path)

一个模块被另一个模块导入的时候起主程序将会运行，如果你想在你的模块被导入时候模块中的某一功能块不执行可以使用__name__属性实现

if __name__ == '__main__':
    print('程序自身在运行')
else:
    print('我来自另一模块')

其它

• 内置dir()函数可以知道模块内定义的所有名称

读取键盘输入

使用input()内置函数从标准输入读取一行文本，默认的标准输入设备是键盘。

arg = input("Enter:")
print("Your input is:", arg)

读写文件

使用open()内置函数打开一个文件，基本语法格式如下：

open(filename, mode)

• filename 你要访问的文件路径&文件名称
• mode 打开文件的模式，只读、读写、追加等等

import os

home = os.environ['HOME']
f = open(home + "/python", "w")
f.write("Hello Python.")
f.close()

读取一个文件的内容：

import os

home = os.environ['HOME']
f = open(home + "/python", "r")
content = f.read()
f.close()
print(content)

异常处理

try:
    raise NameError("Test")
except NameError:
    print("Exception caught.

类

类的定义：

class People:
    age = 0
    name = ""

    # 构造函数
    def __init__(self, age, name):
        print("__init__")
        self.name = name
        self.age = age

    def introduce(self):
        print("Hi, My name is", self.name, "and I'm ", self.age)


p = People(1, "Jim")
p.introduce()

注意⚠️：这里self代表的实例不是类！

类的继承：

class Student(People):
    grade = ""

    def __init__(self, name, age, grade):
        People.__init__(self, age, name)
        self.grade = grade

    # 私有方法
    def __secret(self):
        print("I like sugar.")

    # 共有方法
    def introduce(self):
        self.__secret()
        print("Hi,my name is %s and age %d. I'm %s" % (self.name, self.age, self.grade))

s = Student("Alice", 6, "grade 1")
s.introduce()

• Python支持多继承，如果要继承多个父类用逗号隔开就好。
• 使用__开头的是私有方法

Python Internet模块

协议	功能	端口号	模块
HTTP	网页访问	80	httplib, urllib, xmlrpclib
NNTP	阅读和张贴新闻文章	119	nntplib
FTP	文件传输	20	ftplib, urllib
SMTP	发送邮件	25	smtplib
POP3	接收邮件	110	poplib
IMAP4	获取邮件	143	imaplib
Telnet	命令行	23	telnetlib
Gopher	信息查找	70	gopherlib， urllib

线程

Python3提供了两个标准库_thread和threading对线程支持。

• _thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。
• threading模块除了包含 _thread 模块中的所有方法外还提供了很多的额外方法

Python3推荐使用threading

#! /usr/local/bin python3
import threading
import time

exitFlag = 0

print("---------------启动主线程---------------")

class myThread(threading.Thread):
    def __init__(self, threadId, name, counter):
        threading.Thread.__init__(self)
        #将threadId绑定到当前实例上
        self.threadID = threadId
        self.name = name
        self.counter = counter

    def run(self):
        print("线程开始：" + self.name)
        print_time(self.name, self.counter, 6)
        print("退出线程：" + self.name)


def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print("%s:%s" % (threadName, time.ctime(time.time())))
        counter -= 1

thread1 = myThread(1,"Thread-1",1)
thread2 = myThread(2,"Thread-2",2)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print("---------------退出主线程---------------")

需要区分类属性和实例属性

• 类属性
• 实例属性 -- 通过self绑定到当前的实例上

线程同步

Python使用Thread对象的Lock和Rlock实现线程的同步。

#! /bin/local/bin python3
import threading
import time

class MyThread(threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)

        self.threadID = threadID
        self.name = name
        self.counter = counter

    def run(self):
        print("线程开始" + self.name)
        # 获取线程锁
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # 释放线程锁
        threadLock.release()

threadLock = threading.Lock()
threads = []

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print("%s:%s" % (threadName, time.ctime(time.time())))
        counter -= 1

print("----------------主线程启动----------------")
thread1 = MyThread(1,"Thread-1",3)
thread2 = MyThread(2,"Thread-2",3)

thread1.start()
thread2.start()

threads.append(thread1)
threads.append(thread2)

for t in threads:
    t.join()

print("----------------主线程退出----------------")

输出：

----------------主线程启动----------------
线程开始Thread-1
线程开始Thread-2
Thread-1:Wed Dec 26 15:21:53 2018
Thread-1:Wed Dec 26 15:21:56 2018
Thread-1:Wed Dec 26 15:21:59 2018
Thread-2:Wed Dec 26 15:22:02 2018
Thread-2:Wed Dec 26 15:22:05 2018
Thread-2:Wed Dec 26 15:22:08 2018
----------------主线程退出----------------