Python 基础知识教程

亦凉 2022-06-18 06:54 252阅读 0赞

欢迎加入学习交流QQ群：657341423

--------------------

**Python**

--------------------

序列有两种：tuple（定值表； 也有翻译为元组） 和 list (表)  
列表：可增删改。定义列表用\[\]  
元组：不能增删改，定义用()

范围引用： 基本样式 \[下限:上限:步长\]

> > > print s1\[:5\] \# 从开始到下标4 （下标5的元素 不包括在内）

> > > print s1\[2:\] \# 从下标2到最后

> > > print s1\[0:5:2\] \# 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素 （下标为0，2，4的元素）

> > > print s1\[2:0:-1\] \# 从下标2到下标1  
> > > 注意：这里获得是新的列表，相当于截取列表

s1=\[True,1,‘ad’\]  
删除元素  
del s1\[2\] \# \[True,1\]

增加元素  
s1.append(4) \# \[True,1,‘ad’,4\]

增加另外一个列表  
s1.extend(w) \#w=\[1,2,3\] 结果\#\[True,1,‘ad’,4,1,2,3\]  
s1+w将2个列表连接，从而得出一个新的列表，但不改变s1和w的原来元素。extend是直接增加元素，改变原来的元素.

s1.index(True) 结果 0 返回索引，如果多个，返回的是第一个  
s1.insert(2,‘love’) \# 2为插入位置索引，love是插入值  
s1.pop()移除列表最后一个元素。s1.pop(0) 移除第一个元素。  
s1.remove(‘ad’)移除列表中某个值。如果多个，移除的是第一个  
s1.reverse() 反转  
s1.sort() 排序 \#不保留原来列表。\#如需保留原来列表则：y=sorted(s1)。\#s1.sort(reverse=False)排序设置  
s1.count(‘ad’) \#查询有多小个’ad’  
len(s1) max(s1) min(s1) 查询长度，最大最小值  
Tuple(s1) 转换元组 List(s1) 转换列表

if ‘ad’ in s1:  
print “yes” \#判断某个元素是否在列表,不存在用 not in

--------------------

字符串 //s1=‘hello world how are you?’  
Find查找子字符串，有返回最左端索引，没有返回-1  
s1.find(‘you’)=s1.index(‘you’)//返回结果一样

join连接字符串列表  
如s1=\[‘How’,‘are’,‘you’\]  
s2=’ ’  
s2.join(s1)->“How are you”  
join()为列表或元组

lower返回小写  
s1.lower()  
title首个字母大写  
s1.title()

replace替换  
s1.replace(‘you’,‘do’)

split分割  
s1=‘1+2+3+4+5’  
s1.split(’+’)->\[‘1’,‘2’,‘3’,‘4’,‘5’\]  
如果split()不提供分割符，则以空格，换行符为分割符。

strip去除字符串两侧空格  
strip(’\*’)也可以去除字符串两侧特定的字符，将去除内容作为参数即可  
lstrip,rsplit去除某一侧字符。

translate替换字符，只能处理单个字符。

--------------------

字典  
s1=\{‘lucy’:‘123’,‘Betty’:‘456’,‘Tom’:‘789’\}  
s1=\{键:值\}  
s1=\{\}空字典

dict函数  
items=\[(‘name’,‘lucy’),(‘age’,42)\]  
d=dict(items)->\{‘age’:42,‘name’:‘lucy’\} 通过列表创建字典，注意列表内容格式即可。

d=dict(name=‘lucy’,age=42)  
\->\{‘age’:42,‘name’:‘lucy’\} 通过关键字创建字典  
如果不带参数，创建空字典。

基本字典操作  
len(d)(键-值)数量  
d\[k\] 返回值  
d\[k\]=v 赋值/如果K不存在，自动添加  
del d\[k\] 删除  
k in d 检查是否含键为k的项  
值可以嵌套字典。  
d.clear(),返回空字典，如果有两个以上变量关联该字典，也会一并清空。  
y=d.copy()  
y=deepcopy(d) 使用deepcopy需要引用 from copy import deepcopy  
d.get(‘age’)查找键，如不存在返回None  
d.has\_key(‘age’)=‘age’ in d  
d.items() 返回列表（键值）形式表示  
d.keys() 返回字典键，以列表格式显示  
d.pop(‘name’) 获得键对应的值，然后删除某个键值  
d.update(y) 将y更新到d，如果没有的键值直接添加上去。  
d.values() 返回字典的所有值，列表格式表示。

--------------------

导入函数  
import a as b \# 引入模块a，并将模块a重命名为b  
from a import function1 \# 从模块a中引入function1对象。调用a中对象时，我们不用再说明模块，即直接使用function1，而不是a.function1。  
from a import \* \# 从模块a中引入所有对象。调用a中对象时，我们不用再说明模块，即直接使用对象，而不是a.对象。  
不同路径下：  
1.若在程序cc.py中导入模块a, 需要在a文件夹中建立空文件\_\_init\_\_.py文件;  
然后使用 from aa.a import \*(aa为文件夹名，a为文件名)  
2.多个文件夹  
需要在a文件夹中建立空文件\_\_init\_\_.py文件，然后获取路径在import  
import sys;  
sys.path.append("/home/a/")  
import a

--------------------

包裹传递  
在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。  
下面是包裹位置传递的例子：  
def func(*name):  
print type(name)  
print name  
func(1,4,6)  
func(5,6,7,1,2,3)  
两次调用，尽管参数个数不同，都基于同一个func定义。在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递。  
为了提醒Python参数，name是包裹位置传递所用的元组名，在定义func时，在name前加*号。  
下面是包裹关键字传递的例子：  
def func(\*\*dict):  
print type(dict)  
print dict  
func(a=1,b=9)  
func(m=2,n=1,c=11)  
与上面一个例子类似，dict是一个字典，收集所有的关键字，传递给函数func。为了提醒Python，参数dict是包裹关键字传递所用的字典，在dict前加 \* \*。  
包裹传递的关键在于定义函数时，在相应元组或字典前加 \* 或 \* \* 。

4、解包裹

*  和 \*\*，也可以在调用的时候使用，即解包裹(unpacking), 下面为例：  
    def func(a,b,c):  
    print a,b,c  
    args = (1,3,4)  
    func(\*args)  
    在这个例子中，所谓的解包裹，就是在传递tuple时，让tuple的每一个元素对应一个位置参数。在调用func时使用 \* ，是为了提醒Python：我想要把args拆成分散的三个元素，分别传递给a,b,c。（设想一下在调用func时，args前面没有 \* 会是什么后果？）  
    相应的，也存在对词典的解包裹，使用相同的func定义，然后：  
    dict = \{‘a’:1,‘b’:2,‘c’:3\}  
    func(\*\*dict)  
    在传递词典dict时，让词典的每个键值对作为一个关键字传递给func。

链式赋值  
x=y=10

if XXXX:  
print’a’  
elif aaa:  
print’b’  
else:  
print’c’

while循环  
for循环  
for X in XX:

zip函数 注意3.0以上版本，zip返回的是一个循环对象  
如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：  
ta = \[1,2,3\]  
tb = \[9,8,7\]  
tc = \[‘a’,‘b’,‘c’\]  
for (a,b,c) in zip(ta,tb,tc):  
print(a,b,c)  
每次循环时，从各个序列分别从左到右取出一个元素，合并成一个tuple，然后tuple的元素赋予给a,b,c 。  
zip()函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组，合并成的元组放入zip()返回的列表中。zip()函数起到了聚合列表的功能。

enumerate()函数  
利用enumerate()函数，可以在每次循环中同时得到下标和元素：  
S = ‘abcdefghijk’  
for (index,char) in enumerate(S):  
print index  
print char  
实际上，enumerate()在每次循环中，返回的是一个包含两个元素的定值表(tuple)，两个元素分别赋予index和char。

range() 函数  
使用过 range() 来控制for循环。现在，我们继续开发range的功能，以实现下标对循环的控制：  
S = ‘abcdefghijk’  
for i in range(0,len(S),2):  
print S\[i\]  
在该例子中，我们利用 len() 函数和 range() 函数，用 i 作为 S 序列的下标来控制循环。在range函数中，分别定义上限，下限和每次循环的步长。这就和C语言中的for循环相类似了。

open() 函数  
open()返回的实际上是一个循环对象，包含有next()方法。而该next()方法每次返回的就是新的一行的内容，到达文件结尾时举出StopIteration。这样，我们相当于手工进行了循环。  
自动进行的话，就是：  
for line in open(‘test.txt’):  
print line  
在这里，for结构自动调用next()方法，将该方法的返回值赋予给line。循环知道出现StopIteration的时候结束。  
相对于序列，用循环对象的好处在于：不用在循环还没有开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样，节省了空间，提高了效率，编程更灵活。

break跳出循环  
continue跳过本次循环，执行下一次循环

列表推导式  
表推导(list comprehension)是快速生成表的方法。它的语法简单，很有实用价值。  
假设我们生成表 L ：  
L = \[\]  
for x in range(10):  
L.append(x**2)  
以上产生了表L，但实际上有快捷的写法，也就是表推导的方式:  
L = \[x**2 for x in range(10)\]  
这与生成器表达式类似，只不过用的是中括号

pass  
便于测试，对于没有完成的函数可以这个替代用来测试。

--------------------

类定义  
Class Person:  
def speak(self):  
print’abc’  
Jack=Person()  
Jack.speak()

类继承与重写  
class Aname:  
def SayHello(self):  
print ‘hello’  
def SayWorld(self):  
print ‘hello world’  
class AnameChile(Aname): \#多个继承可用逗号隔开  
def SayHello(self):  
print “world”  
Bname=AnameChile()  
Bname.SayWorld()

类方法私有制  
class Aname:  
def SayHello(self):  
self.\_\_SayWorld()  
def \_\_SayWorld(self): \#私有方法，只能内部访问。  
print ‘hello world’  
Bname=Aname()  
Bname.SayHello()

--------------------

异常  
try:  
pass  
except Exception,e: 在Python 3中必须使用“as”关键字。except Exception as e:  
pass  
finally:  
pass

自定义抛出异常 raise  
def throw\_error():  
raise Exception(“抛出一个异常”)\#异常被抛出，print函数无法执行  
print(“飞天猪”)  
throw\_error()

例子，根据输入内容进行判断，直到能执行除法才停止。  
else子句，try没有异常会执行这个子句内容。  
while True:  
try:  
x=input(‘number:’)  
y=input(‘number2:’)  
value=x/y  
print value  
except Exception,e:  
print e  
print’try again’  
else  
break

--------------------

构造方法 **init** 可以带参数。主要用于方法的初始化。用于类的一些属性设置。（做一些赋值等）  
class FooBar:  
def **init**(self,value=42):  
self.somevar=value  
f=FooBar(‘aaaaaa’)  
f.somevar  
\->aaaaaa

重写和继承  
如果继承一个类，\_\_init\_\_需要重写而且带有父类原来属性的，super函数,全部继承所有父类属性  
class Bird:  
def **init**(self):  
self.hungry=True  
def eat(self):  
print(“Aaah”)  
self.hungry=False  
else:  
print(“No,thanks”)  
class SongBird(Bird):  
def **init**(self):  
super(SongBird,self).**init**()  
self.sound=“Squake”  
def sing(self):  
print(self.sound)

根据实际可以重写标准库的类(UserList,UserString,UserDict)(列表，字符串，字典)

访问器，声明类时，通常将成员变量声明为private，以防止直接访问成员变量而引起的恶意操作。  
class Rectangle:  
def **init**(self):  
self.width=0  
self.height=0  
def setsize(self,size):  
self.width,self.height=size  
def getsize(self):  
return self.width,self.height  
size=property(getsize,setsize)  
r=Rectangle()  
r.width=10  
r.height=5  
r.size  
\->(10,5)  
r.size=100,90  
r.width  
\->100

静态方法和类成员方法(略)

**getattribute**(self,name):当特性name被访问时自动被调用  
**getattr**(self,name):特性name被访问且对象没有相应的特性时被自动调用  
**setattr**(self,name,value):特性name赋值时自动调用  
**delattr**(self,name):特性name删除时自动调用

迭代器：**iter**(略)

闭包的实际例子：  
def line\_conf(a, b):  
def line(x):  
return a\*x + b  
return line  
line1 = line\_conf(1, 1)  
line2 = line\_conf(4, 5)  
print(line1(5), line2(5))  
\->(6,25)  
这个例子中，函数line与环境变量a,b构成闭包。在创建闭包的时候，我们通过line\_conf 的参数a,b说明了这两个环境变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。  
我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。

生成器(generator)的主要目的是构成一个用户自定义的循环对象。  
生成器的编写方法和函数定义类似，只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。  
当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值。  
生成器的特点：  
生成器是一个函数，而且函数的参数都会保留。  
迭代到下一次的调用时，所使用的参数都是第一次所保留下的，即是说，在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的  
下面是一个生成器:  
def gen():  
a = 100  
yield a  
a = a\*8  
yield a  
yield 1000  
该生成器共有三个yield， 如果用作循环器时，会进行三次循环。  
for i in gen():  
print i  
\->100  
\->800  
\->1000

其他函数

--------------------

filter函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True，则该次的元素被储存于返回的表中。  
filter通过读入的函数来筛选数据。  
同样，在Python 3.X中，filter返回的不是表，而是循环对象。  
filter函数的使用如下例:  
def func(a):  
if a > 100:  
return True  
else:  
return False  
print filter(func,\[10,56,101,500\])  
\->\[101,500\]

--------------------

map()是Python的内置函数。它的第一个参数是一个函数对象。  
re = map((lambda x: x+3),\[1,3,5,6\])  
这里，map()有两个参数，一个是lambda所定义的函数对象，一个是包含有多个元素的表。map()的功能是将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表re中。  
map通过读入的函数(这里是lambda函数)来操作数据（这里“数据”是表中的每一个元素，“操作”是对每个数据加3）。  
def func(a):  
if a<100:  
return a-10  
else:  
return a+100  
print map(func,\[10,56,101,500\])

--------------------

可以利用lambda函数的语法，定义函数。lambda例子如下：  
func = lambda x,y: x + y  
print func(3,4)  
lambda生成一个函数对象。该函数参数为x,y，返回值为x+y。函数对象赋给func。func的调用与正常函数无异。  
以上定义可以写成以下形式：  
def func(x, y):  
return x + y

--------------------

多线程  
[http://www.runoob.com/python/python-multithreading.html][http_www.runoob.com_python_python-multithreading.html]

--------------------

标准库功能(附件)  
GUI界面开发(略)  
数据库支持  
python3.X 使用pymysql 在CMD命令行执行：easy\_install.exe pymysql3  
python2.X 使用mysqldb  
windows下直接pip install pymssql \#MSSQL link:[https://pypi.python.org/pypi/pymssql/2.1.3][https_pypi.python.org_pypi_pymssql_2.1.3]  
教程：[http://www.runoob.com/python3/python3-mysql.html][http_www.runoob.com_python3_python3-mysql.html]

--------------------

Python服务器开发(网站开发)原生态，基于socket  
SocketServer其实就是将socket进行封装

--------------------

爬虫 标准库 urllib 或第三方库 requests,scrapy,BeautifulSoup 用于获取数据网站较多。scrapy其实是框架形式，适用于大规模爬取  
首选 scrapy 和 BeautifulSoup  
Splinter，selenium用于操控网站的较多

推荐学习: scrapy,BeautifulSoup,Splinter,selenium(requests可以涉猎一下)

通过pip安装  
pip install scrapy  
pip install requests  
BeautifulSoup 教程: [http://blog.csdn.net/wucl202000/article/details/46292539][http_blog.csdn.net_wucl202000_article_details_46292539] [http://beautifulsoup.readthedocs.io/zh\_CN/latest/\#id13][http_beautifulsoup.readthedocs.io_zh_CN_latest_id13]  
scrapy 教程：[http://scrapy-chs.readthedocs.io/zh\_CN/latest/index.html][http_scrapy-chs.readthedocs.io_zh_CN_latest_index.html] [http://www.jianshu.com/p/fa614bea98eb][http_www.jianshu.com_p_fa614bea98eb]  
requests 教程：[http://blog.csdn.net/shanzhizi/article/details/50903748][http_blog.csdn.net_shanzhizi_article_details_50903748] [http://docs.python-requests.org/zh\_CN/latest/][http_docs.python-requests.org_zh_CN_latest] [http://www.jianshu.com/p/19c846daccb3][http_www.jianshu.com_p_19c846daccb3]  
urllib教程: [http://python.jobbole.com/81336/][http_python.jobbole.com_81336]  
selenium教程 [https://pypi.python.org/pypi/selenium][https_pypi.python.org_pypi_selenium]

Splinter 是一个用 Python 编写的 Web 应用程序进行验收测试的工具。  
Splinter的使用必修依靠Cython、lxml、selenium这三个软件  
python安装在cmd下，输入easy\_install lxml  
python安装pip install selenium（浏览器需要安装WebDriver）  
[https://splinter.readthedocs.io/en/latest/][https_splinter.readthedocs.io_en_latest]

--------------------

单元测试(适用于Python项目中测试)  
注意几点：  
测试类继承unittest.TestCase  
测试类、测试方法名字最好以test开头，很多工具能根据名字来自动运行，很方便  
测试类里面的setUp/tearDown会在每个case执行之前/之后执行，setUpClass/tearDownClass加上@classmethod在整个测试类开始和结束的时候执行  
测试文件的main函数里面加上unittest.main()，就可以直接用python命令运行了  
unittest的基本使用方法：  
1.import unittest  
2.定义一个继承自unittest.TestCase的测试用例类  
3.定义setUp和tearDown，在每个测试用例前后做一些辅助工作。  
4.定义测试用例，名字以test开头。  
5.一个测试用例应该只测试一个方面，测试目的和测试内容应很明确。主要是调用assertEqual、assertRaises等断言方法判断程序执行结果和预期值是否相符。  
6.调用unittest.main()启动测试  
7.如果测试未通过，会输出相应的错误提示。如果测试全部通过则不显示任何东西，这时可以添加-v参数显示详细信息。  
下面是unittest模块的常用方法：  
assertEqual(a, b) a == b  
assertNotEqual(a, b) a != b  
assertTrue(x) bool(x) is True  
assertFalse(x) bool(x) is False  
assertIs(a, b) a is b 2.7版本  
assertIsNot(a, b) a is not b 2.7版本  
assertIsNone(x) x is None 2.7版本  
assertIsNotNone(x) x is not None 2.7版本  
assertIn(a, b) a in b 2.7版本  
assertNotIn(a, b) a not in b 2.7版本  
assertIsInstance(a, b) isinstance(a, b) 2.7版本  
assertNotIsInstance(a, b) not isinstance(a, b) 2.7版本  
更详细的教程见：[http://pyunit.sourceforge.net/pyunit\_cn.html][http_pyunit.sourceforge.net_pyunit_cn.html]

--------------------

Python扩展  
可以下载相应的编译器，然后调用其他语言的包，如Java，C\#  
Jython：[http://baike.baidu.com/item/Jython/8376458?fr=aladdin][http_baike.baidu.com_item_Jython_8376458_fr_aladdin] 实现Python和Java扩展  
IronPython 是一种在 NET 和 Mono 上实现的 Python 语言 Python和.NET一起工作，提供可重用的代码功能而不需要你为了一个环境重写代码库。实现Python和.net扩展。

--------------------

打包  
Distutils包是标准Python库的一部分；主要特点有两个：  
（1）是让用户觉得安装新模块、包和工具的过程是简单、一致又轻松的；  
（2）是让开发者觉得创建这些新模块、包和工具的分发包是简单、一致又轻松的；  
from distutils.core import setup  
setup (  
name = “testpackage”,  
version = “1.0”,  
description = “Distutils sample distribution testpackage”,  
py\_modules = \[‘testpackage’\],  
packages = \[‘TestPackage’\],  
ext\_modules=\[Extension(‘Test’,sources=\[‘Test.c’\])\] \#扩展打包  
)  
三种打包方法

> > > python [setup.py][] sdist //源码安装包  
> > > python [setup.py][] bdist\_wininst //Windows下使用  
> > > python [setup.py][] bdist\_rpm //Linux下使用  
> > > 4.安装  
> > > 源码包的安装是将源码包解压后，[运行setup.py][setup.py 1] install；而Windows和Linux安装包则直接运行安装文件

--------------------

欢迎加入学习交流QQ群：657341423

[http_www.runoob.com_python_python-multithreading.html]: http://www.runoob.com/python/python-multithreading.html
[https_pypi.python.org_pypi_pymssql_2.1.3]: https://pypi.python.org/pypi/pymssql/2.1.3
[http_www.runoob.com_python3_python3-mysql.html]: http://www.runoob.com/python3/python3-mysql.html
[http_blog.csdn.net_wucl202000_article_details_46292539]: http://blog.csdn.net/wucl202000/article/details/46292539
[http_beautifulsoup.readthedocs.io_zh_CN_latest_id13]: http://beautifulsoup.readthedocs.io/zh_CN/latest/#id13
[http_scrapy-chs.readthedocs.io_zh_CN_latest_index.html]: http://scrapy-chs.readthedocs.io/zh_CN/latest/index.html
[http_www.jianshu.com_p_fa614bea98eb]: http://www.jianshu.com/p/fa614bea98eb
[http_blog.csdn.net_shanzhizi_article_details_50903748]: http://blog.csdn.net/shanzhizi/article/details/50903748
[http_docs.python-requests.org_zh_CN_latest]: http://docs.python-requests.org/zh_CN/latest/
[http_www.jianshu.com_p_19c846daccb3]: http://www.jianshu.com/p/19c846daccb3
[http_python.jobbole.com_81336]: http://python.jobbole.com/81336/
[https_pypi.python.org_pypi_selenium]: https://pypi.python.org/pypi/selenium
[https_splinter.readthedocs.io_en_latest]: https://splinter.readthedocs.io/en/latest/
[http_pyunit.sourceforge.net_pyunit_cn.html]: http://pyunit.sourceforge.net/pyunit_cn.html
[http_baike.baidu.com_item_Jython_8376458_fr_aladdin]: http://baike.baidu.com/item/Jython/8376458?fr=aladdin
[setup.py]: http://setup.py
[setup.py 1]: http://xn--setup-tj4o143b.py