十分钟学会Python

原创已于 2023-05-08 10:34:12 修改 · 396 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#数据挖掘

于 2020-06-22 18:55:24 首次发布

本文全面介绍了Python编程语言的基础知识和高级特性，包括数据类型、数据结构、控制流、函数、面向对象程序设计、模块、包、迭代器、生成器、装饰器等核心概念，适合初学者和进阶者学习。

Python学习框架

1 数据类型：
2 数据结构：
3 标识符和关键字
- 3.1 常量、变量、类命名规则
- 3.2 常用内置常量:
4 运算符
- 4.1 逻辑运算符：
- 4.2 比较运算符：
- 4.3 增量赋值运算符：
5 控制流
- 5.1 if判断：
- 5.2 for循环：
- 5.3 内置迭代函数：
- 5.4 while循环流：
- 5.5 break和continue
6 函数：
- 6.1 常用内建函数
- 6.2 lambda
- 7 自定义函数：
8 面向对象程序设计（ Object Oriented Programming ）简称OOP:
- 8.1 定义：
- 8.2 封装：
- 8.3 继承：
- 8.4 多态
9 模块：
- 9.1 调用：
- 9.2 自定义模块：
- 9.3 模块路径：
10 包：
11 Python标准库：
- 11.1 数学模块：
- 11.2 日期与时间：
12 迭代器
- 12.1 自定义迭代器：
- 12.2 内置迭代器：
13 推导或内涵（ list comprehension)
- 13.1 列表推导式
- 13.2 字典推导式
14 生成器（Generator）
15 闭包（closure）
16 装饰器（Decorator）
17 上下文管理器
Tips
- 源的管理

1 数据类型：

为什么要分不同的数据类型？
计算机中不同的数据类型利用的存储方式是不同的，不同数据类型计算实现的原理不同，为了充分利用存储空间和对应计算原理必须定义不同的数据类型申明（即字符，数值，布尔等等）。

1. 字符型
2 数值型（整型、浮点型）
3.布尔型
转换：str(), int(), float()

python调用input()函数输入变量取值，默认是字符串型，需要对应转换数据格式。
genomeName = input( '请输入基因组名称' )
genomeSize = int( input( '请输入基因组大小' ) )

2 数据结构：

1. 序列 字符串 ‘’ #count()	
2. 序列 列表list() or []     	#append()	
3. 序列 元组tuple() or ()	 #不可操作	
4. 非序列 字典dict() or {}	 #append()

序列内置操作-> 排序，索引，切片：
	索引-> listName[0] # 从0开始，0表示第一个数，类似于C语言中数组。  
	
	切片 -> listName[::]  
			-> listName[2:9] # [2, 9) 做闭右开
			-> listName[2:9:2] # step=2,表示每步跳两个数
	type(),
	len(),
	min(),
	max(),
字符串操作：
列表操作：
字典操作：
元祖操作：

3 标识符和关键字

标识符：数字、字母和下划线组成，且不以数字开头。  
关键字：一些特殊的标识符，Python内置好的：如 return, class 等等

3.1 常量、变量、类命名规则

常量：全部大小写-> GENOME_OF_GLB191  
变量、函数名：首单词小写，后每个单词首字母大写-> genomeName  
类：每个单词首字母大写 -> GenomeName

3.2 常用内置常量:

False: None []空列表 ()空元组 {}空字典
True： 非空

4 运算符

4.1 逻辑运算符：

and, or, not, is, is not, in, not in

4.2 比较运算符：

>， >=， <， <=，!=， ==

4.3 增量赋值运算符：

＋、－ 、＊、／、／／、**、%、&、｜、^、>>、<<
如：x += 1

5 控制流

顺序结构，分支结构（判断结构），循环结构。

5.1 if判断：

	if condition： # bool 表达式
		pass
	else:
		pass
或
	if condition:
		pass
	elif condition:
		pass
	elif condition:
		pass
		...
	else:
		pass

5.2 for循环：

	for x in range:
		pass
	else:
		pass
range(start,stop,step)

5.3 内置迭代函数：

	enumerate(seq) ＃编号迭代
	sorted(seq) ＃排序法代
	reversed (seq) ＃翻转法代
	zip (seql , seq2 , ... ) ＃并行迭代

5.4 while循环流：

	while condition: # bool 表达式
		pass
	else:
		pass

5.5 break和continue

break：停止所有循环  
continue：停止当前循环开始下一次循环

6 函数：

6.1 常用内建函数

help()

6.2 lambda

lambda params:expr # lambda x,y:math.sqrt(x+y)

7 自定义函数：

		def hello(形参):  # *：列表， **：字典。
			pass
			return 返回值
		hello(实参) #调用函数		
def simpleExample(a:int, b:float, c:str, *d:list, **e:dict)-> (int, int, str):
	'''
	A simple demo about annotaton of Python function
	'''
	sumResult = a + b + len(c)
    numOFagruments = 3
	return sumResult, numOFagruments, c
print(simpleExample(1, 2.5, "Hellow"))

8 面向对象程序设计（ Object Oriented Programming ）简称OOP:

8.1 定义：

	class 类名(父类名)：
		pass
属性：变量
方法：函数

8.2 封装：

面向过程：针对函数编程
面向对象：将变量（属性）和函数（方法）封装到类中综合管理编程，更符合对显示世界的描述。

		class Dog():
			def __init__(self, name):  # __init__当实例化时便自动执行
				self.name = name		# self指代类实例化后对象本身，self.name在这个类中属于全局变量，而name是实例化类时候要求用户输入的参数
				self.special = 'dog'
			def introduction(self):
				school = CAU 			# CAU便是introduction这个放下的局部变量
				print('Hello, my name is {}, and I am a {}'.format( self.name, self.special ))
				
		if __name__ == '__main__':
		···main function ```
			wang_cai = Dog('wang cai')
			wang_cai.introduction()
										# self专指向这个class本身；
										# 所以self.name之类的变量(属性)，只是在class定义范围内的全局变量；
										# 局部变量不需要前面家'self.'
										# 而__init__(self, 变量1, 变量2, ...)中的变量是外部传入的实参和形参；
										# 所以self.name = name，name赋给self.name后才能在类下的其他方法中被调用（通过调用self.name）

8.3 继承：

父类、子类（派生类）；
父类包含于子类中，因为子类继承了所有父类的属性方法，同时又可以更改；
super().init，自动执行父类中def init(self)这个方法；
更改子类只需要将父类同名方法重写一遍便是覆盖。
关于继承更多知识参阅：https://zhuanlan.zhihu.com/p/285244974
单继承，多继承（按顺序取值）；父类名字或super()替代父类名称；
super()替代父类的名字，避免更改父类名称后，继承该父类的子类大量的改名工作量。

		class Animal():
			'''creating animal class'''
			def __init__(self):
				self.special = 'Aniaml'
			def eat(self):
				print('eat')

			def drink(self):
				print('drink')
			def sleep(self):
				print('sleep')

		class Dog(Animal):
			'''creating dog class from animal'''
			def __init__(self, name):
				self.name = name
				self.special = 'Dog'
			def bark(self):
				print('狗汪汪叫')

		class XiaoTianQuan(Dog):
			def __init__(self):
				self.special = '哮天犬'
			def bark(self):
				print('像神一样的狂吠')
				super().bark()            # 可以保留父类的bark（）方法
				print('hahahahahhah')

		class Cat(Animal):
			'''creating cat class from animall'''

			def __init__(self, name):
				self.name = name
				self.special = 'Cat'
			def cry(self):
				print('呜呜。。。。。。')

		if __name__ == '__main__':
		```	main function ```
			wang_cai = Dog('wang cai')  # 类的实例化成对象
			wang_cai.eat()
			wang_cai.bark()
			mao = Cat('mao')  # 类的实例化成对象
			mao.cry()
			xtq = XiaoTianQuan()  # 类的实例化成对象
			xtq.bark()

8.4 多态

多态是指一类事物有多种形态，比如动物类，可以有猫，狗，猪等等。（一个抽象类有多个子类，因而多态的概念依赖于继承）

class Animal():
	def __init__(self, name):
		self.name = name
	def run(self):
		print("I am runing!")
	def getName(self):
		print('My name is {}'.format(self.name))

class Cat(Animal):
	def Say(self):
		print(' I am a cat')
class Dog(Animal):
	def Say(self):
		print('I am a dog')
class Person(Animal):
	def Say(self):
		print(' I am a person')

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

class Animal():
	def __init__(self, name):
		self.name = name
	def run(self):
		print("I am runing!")
	def getName(self):
		print('My name is {}'.format(self.name))
	def Say(self):
		pass

class Cat(Animal):
	def Say(self):
		print(' I am a cat')
class Dog(Animal):
	def Say(self):
		print('I am a dog')
class Person(Animal):
	def Say(self):
		print(' I am a person')

cat = Cat('mao')
dog = Dog('gou')
human = Person('human')

def function(obj):
	obj.Say()
	return None
function(cat)
function(dog)
function(human)

在这里插入图片描述
综上可以说，多态性是 : 一个接口,多种实现
多态性的好处:

增加了程序的灵活性,以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(obj)
增加了程序额可扩展性,通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(obj)去调用

9 模块：

9.1 调用：

		import 模块名
		import 模块名as 新名字
		from 模块名import 函数名

9.2 自定义模块：

		＃模块文件
		＃文件名称： module_test . py
		
			print （ '导入的测试模块的输出’ ） ＃被导入时会被执行，输出信息
			name = ’ module test ’ ＃定义一个变量
			def m_t_pr () : ＃模块中的函敬定义
				print （ ’ 模块module test 中m t pr （）函数’ ）
				
		＃调用自己编写的模块
		＃文件名： a8_2. py
			import module_test ＃导入模块
			
			module_test.m_t_pr() ＃调用导入模块的的数
			print (’ 使用module_test 模块中的变盘：', module_test .name ) ＃打印 导入悦块中的变量

9.3 模块路径：

	windows：如lib 、lib\site-packages 、dlls 等
	linux：/usr/lib/  /usr/lib64 以及其他的几个子目录下

10 包：

11 Python标准库：

Python 语言中内置的标准库包含200 左右的包和模块，提供了广泛的功能，涵盖数据处理、压缩和散列、数据持久化、数据库操作、文件及文件系统处理、El 志系统、网络通信、Internet协议、数据编码与转换、多进程与多线程等库和模块。除此以外， Python还有大量的第三方库可以使用。

11.1 数学模块：

	random、math

11.2 日期与时间：

	calender、datetime、time

12 迭代器

迭代器是实现了迭代器协议方法的对象或类。

' _iter＿（）”方法返回对象本身，它是for 语句使用迭代器的要求。
“＿next——（）”方法用于返回容器中下一个元素或数据。当容器中的数据用尽时，应该引发Stoplteration 异常。

12.1 自定义迭代器：

class MyIterator(): #自定义迭代器的类
			def __init__(self,x=2,xmax=100): #定义构造方法，初始化实例属性
				self.__mul,self.__x = x,x
				self.__xmax = xmax
			def __next__(self): ＃定义迭代器协议方法，返回类自身
				return self
			def  __next__(self): ＃定义法代器协议方法
				if self.__x and self.__x != 1:
					self.__mul *= self.__x
					if self.__mul <= self.__xmax:
						return self.__mul ＃返回值
					else:
						raise StopIteration ＃引入 Stopiteration 错误
		if __name__ == '__main__':
		```main function```
			myiter = MyIterator() ＃实例化迭代器Myiterator
			for i in myiter: ＃遍历并输出值
				print('迭代的数据元素为', i)

12.2 内置迭代器：

	iter()

13 推导或内涵（ list comprehension)

从一个列表推导出另一个列表

13.1 列表推导式

[ i相关表达式 for i in aiterator if condition ]

13.2 字典推导式

{ key_exp:value_exp for key_exp,value_exp in aiterator if condition }

14 生成器（Generator）

生成器可以生成一个值的序列用于迭代，并且这个值的序列不是一次生成的，而是使用一个，再生成一个，的确可以程序节约大量内存。
生成器则是函数中包含yield 语句的一类特殊的函数。

15 闭包（closure）

常用形式如下：

def out_func(a, b): # 外部函数

	def inner_func(x): # 内部函数
		return lambda x: a * x + b
	return inner_func

line = out_func(3, 5)  # 调用，给定斜率和截距
line(30) # 调用，输入x值并计算

优点点分析

store_log = []
def su(maxNum):
	sum = 0
	for i in range(maxNum):
		store_log.append(i)
		sum = sum + i
	return sum

print(su(100))

使数据更加安全：store_log这个列表在su函数外可能被其他误用等等可能；

def su(maxNum):
	store_log = []
	sum = 0
	for i in range(maxNum):
		store_log.append(i)
		sum = sum + i
	return sum

print(su(100))

此时，虽然能保护store_log但函数不能正常工作；

def bibao(maxNum):
	store_log = []
	def su(maxNum):
		sum = 0
		for i in range(maxNum):
			store_log.append(i)
			sum = sum + i
		return sum
	return su

print(bibao(100))

16 装饰器（Decorator）

装饰器的灵活性很强，可以为一个对象添加新的功能或者给函数插入相关的功能。从本质上说，它是一种代码实现方式，其实就是闭包。

import time

def timer(func): # 装饰函数定义
	
	def wrapper():
		t1 = time.time()
		func()
		t2 = time.time()
		print('执行所用时间为{}'.format(t2 - t1))
	return wrapper

@timer # 语法糖
def have_a_sleep(): # 被装饰函数定义
	time.sleep(5)

have_a_sleep() # 调用

# 如下同样可以实现调用，只是并不简洁
dy = timer(have_a_sleep)
dy()

17 上下文管理器

fd = open('test.txt')
try:
	for line in fd:
		pritn(line)
finaly:
	fd.close()

# 上下文管理器，如下
with open('test.txt') as fd:
	for line in fd:
		print(line)

Tips

源的管理

https://mirrors.tuna.tsinghua.edu.cn/help/pypi/