python基础教程

最新推荐文章于 2023-09-06 14:15:00 发布

raindayinrain

最新推荐文章于 2023-09-06 14:15:00 发布

阅读量633

点赞数

文章标签： Python

本文链接：https://blog.csdn.net/x13262608581/article/details/110112523

版权

1.4.语言-python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

基础

－　变量
先赋值［不用显式指定类型］，后使用．
－　模板
先导入，后使用
如：
import xxx
xxx.fun(xxx)
导入模块xxx
使用模块定义的函数fun
另一种导入形式
如：
from xxx import fun
fun(xxx)
此方式可能引入命名冲突

－　长字符串
"""xxxxxx
xxxxxxxxxx"""
'''xxxxxxxxx
xxxxxxxxxx'''
'xxxx' \
'xxxxxxxx' \
'xxx'

列表和元组

－　列表
xxx = [obj1, obj2, ...] // 每个objx可以是不同类型的对象／常量
－　索引访问
xxx[0] // 访问首个元素
xxx[-1] // 访问尾部第一个元素
xxx[s_index:e_index:step] // s_index指向范围内首个元素索引，e_index指向范围内尾部元素下一位置的索引．step指定步长．
－　拼接
xxx1 + xxx2
－　元素存在性检查
xxx = [obj1, obj2, ...]
objx in xxx // 表达式，返回True/False

xxx = 
[	
[xx1, xx2, ...],
[yy1, yy2, ...],
[zz1, zz2, ...],
...
]
[...] in xxx
－　列表函数
xxx = [obj1, obj2, ...]
len(xxx)
min(xxx)
max(xxx)
xxx[0] = xx
del xxx[1]
xxx.append(xx)
xxx.clear()
xxx2 = xxx // 这是浅拷贝
xxx2 = xxx.copy() // 这是深拷贝
xxx.count(xx) 
xxx.insert(pos, xx)
xxx.pop()
xxx.remove(xx)
xxx.reverse()
xxx.sort()
xxx.sort(key=fun, reverse=True/False)
xxx2 = sorted(xxx) // xxx本身不变
－　元组
>>>1,2,3
(1,2,3)
>>>1,
(1,)
>>>tuple(listobj)
(xx1,xx2,...)
xxx = (1,2,3)
xxx[1]
xxx[0:2]

字符串

－　基本操作
标准列表操作也适用于字符串
但字符串是不可变的
－　格式化１
>>>xxx = "1 %s %s"
>>>yyy = ('aa', 'bb')
>>>xxx % yyy
'1 aa bb'
－　格式化２
>>>from string import Template
>>>tmp = Template("Hello, $x1, $x2")
>>>tmp.substitute(x1="11", x2="22")
Hello,11,22
－　格式化３
>>>"{2} a {1} b {0}".format("i", "am", "xu")
xu a am i
－　格式化４
>>>"{x1} is {x2:.2f}".format(x1="i", x2=2.111)
i is 2.11
>>>"{x1} is {x2:6.2f}".format(x1="i", x2=2.111)
i is    2.11
－　字符串方法
xxx.center(width)
xxx.find(yyy) // 子串寻找
xxx.lower()
xxx.replace(xx1, xx2)
xxx.split/join
xxx.strip() // 去除首尾空白符

－　字典
１．创建和使用
phonebook = {'Alice' : '2341', 'Beth' : '9102', 'Cecil' : '3258'}
d = dict(name='Gumby', age=42)
phonebook['Alice']
２．字典函数
x = {}
len(xxx)
d[k]
d[k] = v
del d[k]
k in d
２．字典方法
xxx.clear()
xxx.get(key) // 直接用xxx[key], key不存在会报错．用get不会．
xxx.items() // 返回由键－值对构成的列表
xxx.keys()
xxx.pop(key)
xxx.values()

用作布尔表达式时，以下值视为假
False None 0 "" () [] {}
－　if
if xxx:
	xxx1
elif xxx:
	xxx2
else:
	xxx3
－　比较运算符
==
<
>
<=
>=
!=
x is y  x,y是否指向同一对象
x is not y
x in y
x not in y

－　断言
assert 条件, 条件不满足时输出内容
－　while
while xxx:
	xxx1
	xxx2
	,,,
－　for
for x in list:
	xxx

for key in map:
	xxx
for key, value in map.items():
	xxx
－　跳出循环
break
continue
－　代码块内容为空时可加个pass作为其内容
－　函数
def hello(name):
	return 'Hello'

>>>hello('world')
－　再谈抽象
类
class Person:
	test = '111'
	def xxx1(self, name):
		self.name = name
		
上述Person类有一个函数成员，两个数据成员
函数成员：xxx1，数据成员name与test
xxx = Person()
上述构造一个Person对象，且xxx指向新构造的对象

python类的成员没有权限保护机制，理论上都是public成员
类的派生
class X1:
	def init(self):
		xxx
	def xx2(self):
		...
class D_X1(X1):
	def init(self):
		xxx // 重写基类方法

D_X1继承了X1的xxx2方法
对类X，通过X.__bases__可访问其基类名称信息
isinstance(obj, class_type)// 判断实例对象是否为类型的实例
对对象X．通过X.__class__可获知此对象所属类信息
hasattr(obj, mem) // 用来检查obj是否含成员mem，返回类型为bool
getattr(obj, mem, default)　// 如obj中含mem成员，返回．否则返回default
callable(obj) // 判断obj是否可调用

－　抽象基类
from abc import ABC, abstractmethod
class Talker(ABC):
	@abstractmethod
	def talk(self):
		pass

@abstractmethod用来将方法标记为抽象的
含有抽象方法的类为抽象类，抽象类不可实例化
class Knigget(Talker):
	def talk(self):
		print("Ni!")

>>>k = Kingget()
>>>isinstance(k, Talker) // 判断k是否为Talker类或其派生类的实例
class Herring:
	def talk(self):
		print("Blub")
>>>h = Herring()
>>>isinstance(h, Talker) // 将返回false

>>>Talker.register(Herring) // 只要执行register不管注册类有没有基类的抽象方法实现均在后续isinstance中返回True
>>>isinstance(h, Talker) // 将返回True


－　异常
>>>raise Exception
>>>raise Exception('hyperddrive overload')
－　自定义的异常类
class SomeCustomException(Exception):
	pass

－　异常捕获／处理
try:
	x = int(input())
	y = int(input())
	print(x/y)
except ZeroDivisionError:
	print("The second number can't be zero")
捕获异常后，可调用raise且不提供任何参数来使其继续向上传播
class MuffledCalculator:
	muffled = False
	def calc(self, expr):
		try:
			return eval(expr)
		except ZeroDivisionError:
			if self.muffled:
				print('Division by zero is illegal')
			else:
				raise

有时捕获异常后，可能想引发别的异常，这时导致进入except子句的异常将被作为异常上下文存储起来，并出现在最终的错误消息中
try:
	1/0
except ZeroDivisionError:
	raise ValueError

捕获多个异常类型及异常对象
try:
	xxx
except (ZeroDivisionError, TypeError) as e:
	print(e)
except:
	xxx // 可捕获所有异常
else:
	xxx // 非异常接着执行这里
finally:
	xxx //　无论发生什么，这里都会执行

－　魔法方法，特性和迭代器
__function__ // 一般都是特定下被python调用的方法
python3中没有旧式类，所有类都将隐式地继承object

构造函数__init__，对象创建后自动调用
class FooBar:
	def __init__(self):
		self.somevar = 42
	def __init__(self, value=42):
		self.somevar = value

class A:
	def hello(self):
		printf("Hello, I'm A")
class B(A):
	pass
对类B的实例调用方法或访问其属性时，如找不到该方法或属性，将在其超类A中查找．
class B(A):
	def hello(self):
		print("Hello, I'm B")
对B的实例调hello将采用B的版本
对构造函数，重写构造函数时，必须调超类［继承的类］的构造函数［c++自动执行，python需显式执行］
class Bird:
	def __init__(self):
		self.hungry = True
	def eat(self):
		if self.hungry:
			print('Aaaah ...')
			self.hungry = False
		else:
		print('No')

class SongBird(Bird):
	def __init__(self):
		self.sound = 'xxx'
	def sing(self):
		print(self.sound)
若对SongBird类实例对象执行eat调用会报错，报错内容为SongBird类无hungry成员．
Python的派生类，在__init__中，需显式调用基类的__init__以避免上述问题．
解决方式１：
class SongBird(Bird):
	def __init__(self):
		Bird.__init__(self)
		self.sound = 'xxx'
	def sing(self):
		print(self.sound)

通过实例调用方法时，方法的参数self将自动关联到实例．
如通过类调用方法，需显式指定self
解决方式２：
class SongBird(Bird):
	def __init__(self):
		super().__init__()
		self.sound = 'xxx'
	def sing(self):
		print(self.sound)

－　元素访问
１．基本的序列和映射协议
要实现序列和映射的基本行为，不可变对象需实现２个方法．可变对象需实现４个．
ａ．__len__(self)
返回集合包含的项数
对序列为元素个数，对映射为键－值对个数．
__len__返回０，相应对象在转化为bool时为false
ｂ．__getitem__(self, key)
返回与指定键相关联的值
对序列，键为０～ｎ－１的整数或负数
对映射，键可为任何类型
ｃ．__setitem__(self, key, value)
以与键相关联的方式存储值
ｄ．__delitem__(self, key)

额外要求：
ａ．对序列
如键为负数，应从尾往前数．
ｂ．如键的类型不合适
可能引发TypeError异常
ｃ．对序列，如索引超出范围，
应引发IndexError

def check_index(key):
	if not isinstance(key, int):
		raise TypeError
	if key < 0:
		raise IndexError

class ArithmeticSequence:
	def __init__(self, start=0, step=1):
		self.start = start
		self.step = step
		self.changed = {}
	def __getitem__(self, key):
		check_index(key)
		try:
			return self.changed[key]
		except KeyError:
			return self.start + key * self.step
	def __setitem__(self, key, value):
		check_index(key)
		self.changed[key] = value

－　从list, dict, str派生
class CounterList(list):
	def __init__(self, *args):
		super().__init__(*args)
		self.counter = 0
	def __getitem__(self, index):
		self.counter += 1
		return super(CounterList, self).__getitem__(index)

－　特性
class Rectangle:
	def __init__(self):
		self.width = 0
		self.height = 0
	
	def set_size(self, size):
		self.width, self.height = size
	
	def get_size(self):
		return self.width, self.height

set_size参数需要为元组，形如(11, 12)
get_size返回值为元组，形如(11, 12)

１．函数property
class Rectangle:
	def __init__(self):
		self.width = 0
		self.height = 0
	
	def set_size(self, size):
		self.width, self.height = size
	
	def get_size(self):
		return self.width, self.height
	size = property(get_size, set_size)
此后可通过size属性进行对关联底层元组的获取和设置．
２．静态方法和类方法
静态方法和类方法的创建：将它们分别包装在staticmethod和classmethod类的对象中，
静态方法定义中没参数self，可直接通过类调用
类方法的定义中含命名为cls的参数．
对类方法，可通过对象直接调用，但cls将自动关联到类．
class MyClass:
	def smeth():
		print('This is a static method')
	smeth = staticmethod(smeth)
	
	def cmeth(cls):
		print('This is a class method of', cls)
	cmeth = classmethod(cmeth)
	
也可用装饰器语法达到类似效果
class MyClass:
	＠staticmethod
	def smeth():
		print('This is a static method')
		
	@classmethod
	def cmeth(cls):
		print('This is a class method of', cls)
	
使用
MyClass().smeth()
MyClass().cmeth()
－　__getattr__, __setattr__等方法
１．__getattribute__(self, name)
在属性被访问时自动调用［适用于新式类］
２．__getattr__(self, name)
在属性被访问而对象没这样的属性时自动调用
３．__setattr__(self, name, value)
试图给属性赋值时自动调用
４．__delattr__(self, name)
试图删除属性时自动调用
－　迭代器
方法__iter__返回一个迭代器，它是包含方法__next__的对象
调用这个方法时可不提供任何参数
调方法__next__时，
迭代器应返回其下一值
如无下一值供返回，引发StopIteration异常．
class Fibs:
	def __init__(self):
		self.a = 0
		self.b = 1
	def __next__(self):
		self.a, self.b = self.b, self.a+self.b
		return self.a
	def __iter__(self):
		return self
	
	fibs = Fibs()
	for f in fibs:
		if f > 1000:
			print(f)
			break
－　从迭代器创建序列
class TestIterator:
	value = 0
	def __next__(self):
		...
		return xxx
	def __iter__(self):
		return self
－　生成器
包含yield语句的函数都被称为生成器
生成器不是使用return返回一个值，而是可以生成多个值．每次一个．
每次用yield生成一个值后，函数将阻塞等待被重新唤醒．
nested = [[1,2], [3,4], [5]]
for num in flatten([nested]):
	print(num)

－　递归式生成器

模块

def hello():
	print('1')
def test()
	hello()
if __name__ == '__main__':
	test()
// __name__在本模块作为主模块执行时为__main__
// 在本模块作为其他模块导入模块时为本模块的名字

－　包
为组织模块，可将其编组为包
模块存储在扩展名为.py的文件中，
而包则是一个目录
要被Python视为包，目录需包含__init__.py
如像普通模块一样导入包，
文件__init__.py的内容就是包的内容．
如一个名为cons的包．
cons/__init__.py中含PI=3.14
则可如下使用
import cons
print(cons.PI)

要将模块加入包，
只需将模块文件放在包目录中．
还可在包中嵌套其他包．
如：

~/python/
~/python/drawing/
~/python/drawing/__init__.py
~/python/drawing/colors.py
~/python/drawing/shapes.py

完成上述后，下面语句均合法：

import drawing// 可用__init__.py中内容
import drawing.colors//可借助drawing.colors用colors.py中内容
from drawing import shapes//可借助shapes用shapes.py中内容

探索模块

－　模块包含什么
print(range.__doc__)

标准库模块

－　sys
sys.argv包含传递给python解释器的参数［含脚本名］
sys.exit退出程序
sys.path
sys.stdin
sys.stdout
sys.stderr
－　os
os.environ //os.environ['PYTHONPATH']
os.system
os.sep
os.linesep
－　fileinput
fileinput.input，返回一个可在for循环中进行迭代的对象
fileinput.filename
fileinput.lineno
－　集合，堆，双端队列
{}//集合
[]//列表
集合成员函数
union
issubset
issuperset
intersection
difference
copy
－　堆模块-heapq
heappush(heap, x)// heap为[]对象
heappop(heap)
heapify(heap)
heapreplace(heap,x)
nlargest(n, iter)
nsmallest(n, iter)
－　双端队列
from collections import deque
－　time
－　random

文件

－　打开文件
f = open('xxx')
f = open('xxx', 'x')
f.write('xxx')
f.close()
f.read([num])
f.readline([num])
f.readlines()

with open(filename) as f:
	while True:
		char = f.read(1)
		if not char:
			break
		process(char)
with open(filename) as f:
	while True:
		line = f.readline()
		if not line:
			break
		process(line)

一个UI模块－tkinter

from tkinter import *

数据库支持

网络支持

raindayinrain

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
python基础教程

－　变量先赋值［不用显式指定类型］，后使用．－　模板先导入，后使用如：import xxxxxx.fun(xxx)导入模块xxx使用模块定义的函数fun另一种导入形式如：from xxx import funfun(xxx)此方式可能引入命名冲突－　长字符串"""xxxxxxxxxxxxxxxx"""'''xxxxxxxxxxxxxxxxxxx''''xxxx' \'xxxxxxxx' \'xxx'...
复制链接

扫一扫