学习python基础（一）

最新推荐文章于 2023-04-21 16:12:52 发布

嘿嘿潶黑黑

最新推荐文章于 2023-04-21 16:12:52 发布

阅读量419

点赞数 1

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/m0_37623485/article/details/103920141

版权

Python 专栏收录该内容

3 篇文章 1 订阅

订阅专栏

python特性概要

1 python是脚本解释型语言。
2 python特性总结：字节码，动态，缩进

2.1 字节码
2.2 动态语义 在赋值时确定数据类型
2.3 缩进

不同类型编程语言的区别

解释性语言的内部机制

在运行脚本之前，得到结果之后
1.python先将脚本编译成字节码(pyc,pyo)
2.python虚拟机解释并运行字节码文件

编译型语言的内部机制

1.先将源码变成成机器码(机器能读懂的代码)，生成可执行文件
2.运行可执行文件

三内置

type()
help()
dir()

python基本数据类型讲解

1 一切皆为对象

对象：
属性
方法

2 数据类型的组成

组成3部分：
身份
类型
值

3 常用基本数据类型

int 整型
boolean 布尔
string 字符串
list 列表
tuple 元组
dict 字典

4 数据类型的可变和不可变

不可变类型：int,string,tuple
可变类型：list,tuple,dict

5 变量的赋值一切皆为引用
6 互相转换

字符串的认知

1、字符串的概念
2、ascii unicode utf8编码
python默认的文件编码都是ascii

len的应用
len(str) —字符串的长度
转义符让文本更好处理
a = ‘abcd’’
前缀
u"哈哈哈" —使用utf8编码
r"哈哈哈" —不要转义
访问子字符串，序列
a = “abcde”
print(a[2])
成员是有序排列的，可以通过下标偏移量访问到它的一个或者有限个成员
替换字符串
str.replace(str,‘str1’)
字符串拼接
“abd”+“ab” —不建议使用

推荐使用占位符
%s 字符串占位符
%d 数字占位符
推荐使用的方法
“,”.join([a,b,c])
读写文本
d = open(‘filename’,‘openWay’) 打开文件
openWay:
w write
r read
a append
d.write(‘data’) 向文件里面写数据
d.close() 关闭文件
d.read(byte) 读文件
d.seek() 定义游标
序列
有序的集合
通过偏移来索引，从而读取数据
支持嵌套
可变的类型
添加操作
+ 生成一个新的列表
extend 接受参数并将该参数的每个元素都添加到原有的列表中，原地修改泪飙而不是新建列表
append 添加任意对象到列表的末端
insert 插入任意对象到列表中，可以控制插入位置
修改操作
直接赋值操作即可
删除操作
del 通过索引删除指定位置的元素
remove 移除列表中指定值的第一个匹配值。没找到，会抛出异常
pop 返回最后一个元素，并从list中删除它
成员关系
in not in 判断一个元素是否在列表里，返回一个bool类型
列表推导式
1.首先骶韧带iterable中所有内容，每一个迭代，都把iterable里相对应的内容放到iter_var中，在表达式中应用该内容，最后用表达式的值生成一个列表
例：
生成一个包含1到10的列表
[x for x in range(1,11)]
2.加入了判断语句
例：
生成一个包含1到10的所有奇数列表
[x for x in range(1,11) if x % 2 == 1]
排序翻转
sort 直接修改原列表，返回值为none，下方法相同
reverse

列表的应用

内置list方法
返回一个列表，参数是可迭代对象
xrange和range的具体区别
2.1 xrange的用法(python3中无此方法)
xrange(开始，结束，步长)
2.2 比较
range 直接生成一个list对象
xrange 生成一个xrange对象，需要操作非常大的数据，且内存比较紧张时，可以使用xrange来操作
例子：(基于python2)
for m in range(1000):
if m == 10:
print ‘sss’
break

元组

1.特点
有序的结合
通过偏移来取数据

属于不可变的对象，不能在原地修改内容，没有排序，修改等操作
2.为什么要有元组
元组不可变的好处。保证数据的安全
3.转换
a = (1,2,3)
b = list(a)
修改数据
a = tuple(b) —修改为元组

集合

集合时没有顺序的概念，所以不能用切片和索引操作
创建集合
	set() 可变的
	frozenset() 不可变的
添加操作
	add
	update
删除操作
	remove
成员关系
	in,not in
并集，交集，差集
	& | -
set去重
列表内容元素重复

字典

· 字典是无序的，不能通过偏移来存取，只能通过键值对来存取
· 字典 = {‘key’：‘value’}
· 特点：
内部没有顺序，通过键来读取值，可嵌套，并且可以原地修改内容
组成字典的键必须是不可变的数据类型，比如：数字，字符串，元组等
· 操作
1创建字典
{} info={‘name’:‘lilei’,‘age’:20}
dict() info=dict(name=‘lilei’,age=20)
2添加内容
a[‘xx’] = ‘xx’
3修改内容
a[‘xx’] = ‘xx’
update参数是一个字典的类型，会覆盖相同键的值
info.update({‘city’:‘beijing’})
4删除 del,clear,pop
del info[‘phone’] 删除某个元素
info.clear() 删除字典的全部元素
info,pop(‘name’)
5in和has_key()成员关系操作
phone in info
info.has_key(‘phone’)
6

	keys() 返回的是列表，里面包含了字典的所有键
	values() 返回的是列表，里面包含了字典的所有值
	items()生成一个字典的容器:[()]
7get		
	info.get('name')

python语句讲解

print语句

基本输出
print “” ----python2
print() ----python3
print的逗号

python2

print “” ,
print “” ----逗号表示此处还没有结束，下一行接着

python3

在输出内容外加,会将输出内容变成元组
使用返回语句 return i, 会使输出内容变成一行
输出到文件 >> 为重定向

python2

f = open(“filename”,“w”)
print >> f,“inputContext”
f.close()

python3

f = open(“filename”,“w”)
print(“inputContext”,file=f)
f.close();

控制流语句(control flow)

由条件和执行代码块组成
条件分为决策、循环和分支
格式(冒号与缩进的4个空格永不忘)
if while for 函数

布尔值

布尔值最基本的运算符

and 全部为真
or 至少一项为真
is 检查共享
== 检查值
not
其他若干比较符号

if语句

格式
if 条件:
elif 条件:
else:
pass —什么都不执行
三元表达式
x if else
例子
4 if True else 3
==
if True:
print(4)
else:
print(3)
[4,3][True]
[假的答案，真的答案][真]

while语句

格式
while 条件:
语句
组成部分
break结束while
continue跳出当前次循环
else 在循环结束后执行代码块，但不可以与break一起用

for语句

格式
for item in iterable:
语句
for最后一个迭代值将被保存

with语句

with open(‘a.txt’,‘a’) as g:
g.write(‘xixi’)
等价于
g = open(‘a.txt’,‘a’)
g.write(“hsdf”)
g.close()

maketrans和translate语句

使用translate替换字符

	import string
	g = string.maketrans('123','abc')
	a = '123456789'
	print(a.translate(g))
	
	<=====结果=======>
	
	abc456789

使用translate删除字符

python2
	import string
	g = string.maketrans('123','abc')
	a = '321123321'
	print(a.translate(g,'1'))

python3
g = bytes.maketrans(b’123’,b’abc’)
a = b’321123321’
print(a.translate(g,b’1’))

<=结果===>

cbbccb

函数

函数是抽象的第一步

结构

	def 函数名(参数):
		代码块
		return

函数文档

	def test():
		"哈哈哈"
		return "3"
		
	print(test.__doc__)
	
	===========结果==========

	哈哈哈

参数
· 位置参数
填几个参数就得填几个值
· 可选参数

	def test(a = 4):
		return a
		
	print(test())
	print(test(a = 5))

全局变量
global b

**和 *的用法
	**代表字典 *代表元组
	
	**例子：
	def test(**kr):
		return kr
		
	print(test(c=1,g=24))
	
	*例子：
	def test(*z):
		return z
		
	print(test(1,2,5))

lambda

lambda是一个表达式
他没有名称，存储的也不是代码块，而是表达式
它被用作执行很小的功能，不能在里面使用条件语句，但可以使用常规的运算符

例子：
d = lambda x:x+1
print(d(2))

filter

用于过滤
例子：
t = [1,2,3,4,5]
g = filte(lambda x:x > 3 , t)
print(g)

类

定义一个class
class test(object):

		'''
		构造方法
		'''
		def __init__(self):
			pass
		def __init__(self,var1):
			self.var1 = var1
		
		'''
		析构函数，用于删除对象
		'''
		del __del__(self):
			del self.var1
		
		'''
		get被称之为test对象的方法
		
		注意：self是默认的一个参数，代表对象本身，必须加
		
		'''
		def get(self):
			return "heihei"
	
		pass
		
	'''
	t是类test的一个实例	
	'''		
	t = test()
	print(t.get())

模块

哪里找模块
pypi
选择那些模块
首选内置模块
常用模块
urllib urllilb2 网络
datatime time 时间
os 系统
pickle 对象序列化
常用数据交换格式json xml
bsddb key=>value 轻量级数据库
logging 日志
查看模块的方法
dir(模块名）

异常

异常的使用

a = [1,2,3,4,5,6]

try:
print(a[6])
except:
print(“error,hhhh”)

print(“go on”)

例子：
try:
框住你感觉会抛出异常的代码
print()
exception:
代码出错，执行的内容
print()
else:
假设try代码块里面没有抛出异常，执行这里
print()
finally:
不管如何总会执行
print()

日志

import logging

logger = logging.getLogger()

hdlr = logging.FileHandler(’/tmp/sendlog.txt’)

formatter = logging.Formatter(’%(asctime)s %(levelname)s %(message)s’)

hdlr.setFormatter(formatter)

logger.addHandler(hdlr)

logger.setLevel(logging.NOTSET)

logger.debug(‘this is debug message’)

logger.error(‘this is error message’)

with语句

with open(‘a’,‘r’) as a:
e = a.read()

进入时，调用对象的__enter__方法
退出时，调用对象的__exit__方法

class stj(object):
	def __enter(self):
		print(u"hhhh")
	def __exit__(self,type,value,traceback):
		print(u"exit")

with sth() as s:
	pass

自定义异常

必须继承Exception

class myException(Exception):
	def __init__(self,error,msg):
		self.args = (error,msg)
		self.error = error
		self.msg = msg
	
try:	
	return myException(1,'my exception')
exception Exception as e:
	print(str(e))

多线程

进程

进程 pid 唯一标识符
使用kill 杀死进程

主线程创造一个进程的时候，会创造一个线程，这个线程被称为“主线程”
一个进程里只有一个主线程

python中的多线程，不是真正意义上的多线程

全局锁(GIL)
在任意的指定时间里，有且只有一个线程在运行

import threading

def test():
	print(1)
'''
a = threading.Thread(target=test)
b = threading.Thread(target=test)

a.start()
b.start()

a.join()
b.join()
可以使用迭代来重复上面操作
'''
ts = []

for i in range(15):
	th = threading.Thread(target=test,args=[i])
	th.start()
	ts.append(th)
	
for i in ts:
	 i.join()
	 
print("hee")

join()的作用，等待其他线程跑完才会继续运行主线程

io操作要用到多线程时，必须要Lock acquire release
RLock 可重新入锁

import threading

mlock = threading.Lock()

num = 0

def a():
	global num
	
	mlock.acquire() #加锁
	num += 1
	mlock.release() #释放
	
	print(num)
	
for i in range(10):
	d = threading.Thread(target=a)
	d.start()

协程

yield 生成器
1、包含yield的函数，则是一个可迭代对象
利用next方法，取每一次的yield
send的方法，设置yield的值
2、生产者，消费者行为
3、无需立刻执行，需要时才执行
4、斐波那契的例子

正则表达式

正则表达式，是字符串检索引擎，最早起源于unix
python中的正则模块 re

基本概念

[0-9] 或者\d 全部数字
\w 全部单词类字符 a-z 0-9 A-Z _
\W 非单词类字符
{2} {n} 前面的匹配n次
{n,m} 前面的匹配n到m次
+ 前面的表达式出现1到无限次
? 前面的表达式出现1次
* 前面的表达式出现0到无限次

基本操作

一次取配 match:"hello lilei" r'(\w+) (\w+)'
切割split
查找全部 findall
finditer 迭代器

socket

udp,tcp/ip,socket

HTTP TCP/IP
qq udp

netcat

linux上的程序

socket服务器

1、创建socket对象
socket.socket(1,2)
1.1、 AF_INET 或 AF_UNIX
1.2、 SOCK_STREAM tcp/ip
SOCK_DGRAM udp
2、绑定端口
socket.bind((‘localhost’,8888))
3、socket.listen(n)
n代表允许多少个同时请求
4、connection.address = sock.accept()
5、buf = connection.recv(100)
6、connection.send(buf)
7、connection.close()

多线程爬虫

抓取流程

分析
分析工具 firebug
urllib足矣，还有scrapy
分析数据,正则或beautifulsoup

嘿嘿潶黑黑

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
学习python基础（一）

python特性概要1 python是脚本解释型语言。2 python特性总结：字节码，动态，缩进2.1 字节码2.2 动态语义在赋值时确定数据类型2.3 缩进不同类型编程语言的区别解释性语言的内部机制在运行脚本之前，得到结果之后1.python先将脚本编译成字节码(pyc,pyo)2.python虚拟机解释并运行字节码文件编译型语言的内部机制1.先将源码变成成机器码(...
复制链接

扫一扫