Python基础之常识概念

最新推荐文章于 2024-06-01 10:35:00 发布

A.Monster

最新推荐文章于 2024-06-01 10:35:00 发布

阅读量172

点赞数

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

本文链接：https://blog.csdn.net/weixin_45591261/article/details/105086544

版权

Python基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

概念常识

1、深浅拷贝

1.1、copy与deepcopy(What)

copy：不管多么复杂的数据结构，浅拷贝只会copy一层
deepcopy：深拷贝会完全复制原变量相关的所有数据，在内存中生成一套完全一样的内容，我们对这两个变量中任意一个修改都不会影响其他变量

2、垃圾回收机制

2.1、引用计数

原理
- 当一个对象的引用被创建或者复制时，对象的引用计数加1；当一个对象的引用被销毁时，对象的引用计数减1
- 当对象的引用计数减少至0，意味着该对象已经不被使用，其内存将可以被释放
引用计数的优缺点
- 优点
  - 引用计数有个很大的优点，即实时性，任何内存，一旦没有指向它的引用，就会被立即回收，而其他的垃圾回收技术必须在某种特殊条件下才能进行无效内存的回收
- 缺点
  - 引用计数机制所带来的维护引用计数的额外操作与Python运行中所进行的内存分配和释放，引用复制的次数是程正比的
  - 显然比其他哪些回收机制所带来的额外操作只是与待回收的内存数量有关的效率要低
  - 同时，因为对象之间互相引用，每个对象的引用都不会为0，所以这些对象所占用的内存始终都不会被释放掉

2.2、标记清除

原理
- 它分为两个阶段，第一阶段是标记阶段，GC会把所有的活动对象打上标记，第二阶段是把哪些没有标记的对象非活动对象进行回收
- 对象之间通过引用(指针)连在一起，构成一个有向图
- 从根对象(root object)出发，沿着有向边遍历对象，可达的(reachable)对象标记为活动对象，不可达的对象就是要被清除的非活动对象
- 根对象就是全局变量、调用栈、寄存器
- 在上图中，可以从程序变量直接访问1，并且可以间接访问2/3，程序无法访问4/5
  - 第一步将标记1，并记住2/3以供稍后处理
  - 第二步将标记2，第三步将标记3，但不记得2，因为已经标记过了
  - 扫描阶段将忽略1/2、3，因为他们已被标记，但会回收4/5

2.3、分代回收

分代回收是建立在标记清除基础之上的，是一种以空间换时间的操作方式
Python将内存分为了3代，分别为年轻代、中年代、老年代
他们对应的三个链表，他们的垃圾收集频率与对象存活时间的增大而减小
新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发
把那些可以被回收的对象回收掉，而那些不会回收的对象就会被转移到中年代上去，以此类推
老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内

3、is和==区别

is不仅仅数据一样，内存地址也相同
== 只判断数据和数据类型一样即可

4、读写文件

4.1读写文件(python如何读取大文件)

open函数用来打开文件
三种读操作(readline、readlines、read)
- 使用read(n)读文件时，n指定长度的文件
  - seek(offset[,whence])，随机访问或指定位置
  - tell，返回当前读取文件的位置下标
- readline()，读一行文件
- readlines()，把文件都读入内存中，速度增加，内存消耗大

4.2、经典面试题：现有一个5G的文件，用Python写入另一个文件里

**read()😗*指定读取指定大小的文件（默认一次读取所有）
**readline()😗*逐行读取，适合读大文件
**readlines()😗*一次性读取所有文件，将文件按行读取成列表
我们使用了一个while循环来读取文件内容，每次最多读取8kb大小
这样我们可以避免之前需要拼接一个巨大字符串的过程，把内存占用率降低

# -*- coding: utf-8 -*-
def read_big_file_v(fname):
    block_size = 1024 * 8
    with open(fname,encoding="utf8") as fp:
        while True:
            chunk = fp.read(block_size)
            # 当文件没有更多内容时，read 调用将会返回空字符串 ''
            if not chunk:
                break
            print(chunk)
path = r'C:\aaa\luting\edc-backend\tttt.py'
read_big_file_v(path)

5、字符编码

5.1、各种编码由来

ASCII：不支持中文(一个字母一个字节：a/b/c)
GBK：是中国的中文字符，其中包含了简体中文以及繁体中文
Unicode：万国编码(Unicode中就包含了GBK)

5.2、Unicode(每个字母需要两个字节)

存储所有字符串都用两个字节
Unicode是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了同并且唯一的二进制编码
规定所有的字符和符号最少由16位来表示(2个字节),即：2 ** 16 = 65536
这里还有个问题：使用的字节增加了，那么造成的直接影响就是使用的空间就直接翻倍了

5.3、utf-8：可变长码，是Unicode的扩展集

UTF-8编码：是对Unicode编码的压缩和优化，他不再使用最少使用两个字节，而是将所有的字符和符号进行分类
ascii码中的内容是用一个字节保存、欧洲的字符用两个字节保存，东亚的字符用三个字节保存
存一个a字母用一个字节，存一个汉字用三个字节

5.4、Python2与Python3的几个区别

Python2默认编码方式为ASCII， Python3 默认编码方式为UTF-8（是Unicode 的扩展集）
python2中字符串有str和unicode两种类型， python3 中字符串有str和字节(bytes) 两种类型
python3中不再支持u中文的语法格式

5.5、python2和python3中编码转换

在python3中字符串默认是unicode所以不需要decode()，直接encode成想要转换的编码如gb2312
在python2中默认是ASCII编码，必须先转换成Unicode，Unicode 可以作为各种编码的转换的中转站

6、常用模块

6.1、subprocess模块

subprocess原理以及常用的封装函数
- 运行python时，我们都是在创建并运行一个进程；像Linux进程那样，一个进程可以fork一个子进程，并让这个子进程exec另外一个程序
- 在Python中，我们通过标准库中的subprocess包来fork一个子进程，并运行一个外部的程序。
- subprocess包中定义有数个创建子进程的函数，这些函数分别以不同的方式创建子进程，所以我们可以根据需要来从中选取一个使用
- 另外subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。

6.2、subprocess.Popen()

实际上，上面的几个函数都是基于Popen()的封装(wrapper)，这些封装的目的在于让我们容易使用子进程
当我们想要更个性化我们的需求的时候，就要转向Popen类，该类生成的对象用来代表子进程
与上面的封装不同，Popen对象创建后，主程序不会自动等待子进程完成。我们必须调用对象的wait()方法，父进程才会等待 (也就是阻塞block)
从运行结果中看到，父进程在开启子进程之后并没有等待child的完成，而是直接运行print。
- child.poll() # 检查子进程状态
- child.kill() # 终止子进程
- child.send_signal() # 向子进程发送信号
- child.terminate() # 终止子进程

6.3、subprocess.PIPE 将多个子进程的输入和输出连接在一起

subprocess.PIPE实际上为文本流提供一个缓存区。child1的stdout将文本输出到缓存区，随后child2的stdin从该PIPE中将文本读取走
child2的输出文本也被存放在PIPE中，直到communicate()方法从PIPE中读取出PIPE中的文本。
注意：communicate()是Popen对象的一个方法，该方法会阻塞父进程，直到子进程完成

7、paramiko的使用

在windows中安装paramiko: pip3 install paramiko

7.1、linux中scp命令的使用

ssh root10.1.0.51 # ssh远程登录
scp -rp aa.txt root@10.1.0.51：/tmp/ # 将本地aa.text文件复制到10.1.0.50的/tmp文件夹中

7.2、Paramiko模块作用

1）如果需要使用SSH从一个平台连接到另外一个平台，进行一系列的操作时，
**比如：**批量执行命令，批量上传文件等操作，paramiko是最佳工具之一。
2）paramiko是用python语言写的一个模块,遵循SSH2协议,支持以加密和认证的方式，进行远程服务器的连接
3）由于使用的是python这样的能够跨平台运行的语言，所以所有python支持的平台，如Linux, Solaris, BSD,MacOS X, Windows等，paramiko都可以支持
4）如果需要使用SSH从一个平台连接到另外一个平台，进行一系列的操作时，paramiko是最佳工具之一
5）现在如果需要从windows服务器上下载Linux服务器文件：
- a. 使用paramiko可以很好的解决以上问题，它仅需要在本地上安装相应的软件（python以及PyCrypto）
- b. 对远程服务器没有配置要求，对于连接多台服务器，进行复杂的连接操作特别有帮助。

8、re模块

8.1、常用正则表达式符号

通配符（ . ），作用：点（.）可以匹配除换行符以外的任意一个字符串
⒉转义字符（ \ ），作用:可以将其他有特殊意义的字符串以原本意思表示
⒊字符集，作用：使用中括号来括住字符串来创建字符集，字符集可匹配他包括的任意字串
⒋管道符，作用：一次性匹配多个字符串
⒌可选项和重复子模式（在子模式后面加上问号？），作用：在子模式后面加上问号，他就变成可选项，出现或者不出现在匹配字符串中都是合法的
⒍字符串的开始和结尾
- ① ‘w+’ 匹配以w开通的字符串
- ② ‘^http’ 匹配以’http’ 开头的字符串
- ③‘ $com’ 匹配以‘com’结尾的字符串
7.最常用的匹配方法
　　　　　　 \d 匹配任何十进制数；它相当于类 [0-9]。
　　　　　　 \D 匹配任何非数字字符；它相当于类 [^0-9]。
　　　　　　 \s 匹配任何空白字符；它相当于类 [ fv]。
　　　　　　 \S 匹配任何非空白字符；它相当于类 [^ fv]。
　　　　　　 \w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
　　　　　　 \W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]。
　　　　　　 \w* 匹配所有字母字符
　　　　　　 \w+ 至少匹配一个字符

8.2、re模块常用函数

函数	描述
compile(pattern[, flags])	根据正则表达式字符串创建模式对象
search(pattern, string[, flags])	在字符串中寻找模式
match(pattern, 常用模块[, flags])	在字符串的开始处匹配
split(pattern, string[, maxsplit=0])	根据模式的匹配项来分割字符串
findall(pattern, string)	列出字符串中模式的所有匹配项并以列表返回
sub(pat, repl, string[, count=0])	将字符串中所有pat的匹配项用repl替换
escape(string)	将字符串中所有特殊正则表达式字符转义

⒈ re.compile(pattern[, flags])
- 1）把一个正则表达式pattern编译成正则对象，以便可以用正则对象的match和search方法
- 2）用了re.compile以后，正则对象会得到保留，这样在需要多次运用这个正则对象的时候，效率会有较大的提升

import re
mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
ret = re.match(mobile_re,'18538762511')
print(ret)            # <_sre.SRE_Match object; span=(0, 11), match='18538652511'>

⒉ search(pattern, string[, flags]) 和 match(pattern, string[, flags])

1）match ：只从字符串的开始与正则表达式匹配，匹配成功返回matchobject，否则返回none；
2）search ：将字符串的所有字串尝试与正则表达式匹配，如果所有的字串都没有匹配成功，返回none，否则返回

matchobject；
import re
a =re.match('www.bai', 'www.baidu.com')
b = re.match('bai', 'www.baidu.com')
print(a.group())                                # www.bai
print(b)                                        # None

# 无论有多少个匹配的只会匹配一个
c = re.search('bai', 'www.baidubaidu.com')
print(c)                                        # <_sre.SRE_Match object; span=(4, 7), match='bai'>
print(c.group())                                # bai

3 split(pattern, string[, maxsplit=0])
- 作用：将字符串以指定分割方式，格式化成列表
  import re
  text = ‘aa 1bb###2cc3ddd’
  print(re.split(’\W+’, text)) # [‘aa’, ‘1bb’, ‘2cc3ddd’]
  print(re.split(’\W’, text)) # [‘aa’, ‘1bb’, ‘’, ‘’, ‘2cc3ddd’]
  print(re.split(’\d’, text)) # [‘aa ‘, ‘bb###’, ‘cc’, ‘ddd’]
  print(re.split(’#’, text)) # [‘aa 1bb’, ‘’, ‘’, ‘2cc3ddd’]
  print(re.split(’#+’, text)) # [‘aa 1bb’, ‘2cc3ddd’]

⒋ findall(pattern, string)

作用：正则表达式 re.findall 方法能够以列表的形式返回能匹配的子串

import re
p = re.compile(r'\d+')
print(p.findall('one1two2three3four4'))             # ['1', '2', '3', '4']
print(re.findall('o','one1two2three3four4'))        # ['o', 'o', 'o']
print(re.findall('\w+', 'he.llo, wo#rld!'))         # ['he', 'llo', 'wo', 'rld']

⒌ sub(pat, repl, string[, count=0])
- 1）替换，将string里匹配pattern的部分，用repl替换掉，最多替换count次然后返回替换后的字符串
- 2）如果string里没有可以匹配pattern的串，将被原封不动地返回
- 3）repl可以是一个字符串，也可以是一个函数
- 4）如果repl是个字符串，则其中的反斜杆会被处理过，比如 \n 会被转成换行符，反斜杆加数字会被替换成相应的组，比如 \6 表示pattern匹配到的第6个组的内容
```
import re
test="Hi, nice to meet you where are you from?"
print(re.sub(r'\s','-',test))          # Hi,-nice-to-meet-you-where-are-you-from?
print(re.sub(r'\s','-',test,5))        # Hi,-nice-to-meet-you-where are you from?
print(re.sub('o','**',test))           # Hi, nice t** meet y**u where are y**u fr**m?
```
⒍ escape(string)
- 1） re.escape(pattern) 可以对字符串中所有可能被解释为正则运算符的字符进行转义的应用函数。
- 2）如果字符串很长且包含很多特殊技字符，而你又不想输入一大堆反斜杠，或者字符串来自于用户(比如通过raw_input函数获取输入的内容)，且要用作正则表达式的一部分的时候，可以用这个函数
```
import re
print(re.escape('www.python.org'))
```

8.3、re模块中的匹配对象和组 group()

1）group方法返回模式中与给定组匹配的字符串，如果没有给定匹配组号，默认为组0
2）m.group() == m.group(0) == 所有匹配的字符

8.4、4、re模块其他知识点

import re
#匹配时忽略大小写
print(re.search("[a-z]+","abcdA").group())                #abcd
print(re.search("[a-z]+","abcdA",flags=re.I).group())            #abcdA
#连同换行符一起匹配：
#'.'默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
print(re.search(r".+","\naaa\nbbb\nccc").group())            #aaa
print(re.search(r".+","\naaa\nbbb\nccc",flags=re.S))            
        #<_sre.SRE_Match object; span=(0, 12), match='\naaa\nbbb\nccc'>
print(re.search(r".+","\naaa\nbbb\nccc",flags=re.S).group())
                                                                                   aaa
                                                                                   bbb
                                                                                   ccc

9、python2与python3的区别

9.1、raw_input与input

从键盘中输入内容时，python2用的是raw_input,而python3使用的是input（如下图所示）

Python2：

>>> raw Input(请输入您的名字:")
请输入您的名字: nihao
'nihao’

python3:

input(请输入您的名字:)
请输入您的名字: nihao
nihao

9.2、print与print()

打印时python2使用的是print + 内容
```
print hello pvthon'
he11o python
```
python3 则是print(内容)
```
print('he11o python')
he11o python
```

9.3、/与//的区别

python2中 / 表示整除（取整数），// 也表示整除（取整数),也就是说，python2中/和//都表示整除（取整数)
```
>>>a=7
>>>b=a//2
>>>b
3
>>>c=a/2
>>>c
3
```
python3中 / 表示的是做除法运算（不一定为整数），而//表示的是整除（取整数）
```
>>>a=7
>>>b=a//2
>>>b
>>>c=a/2
>>>c
3.5
```

9.4、不等运算符<>与！=

python2中<>与！=都可以使用，都表示不相等的判断
```
>>>2<>3
True
>>>2!=3
True
```
而python3就不一样了，python3表示不相等的判断时只能用！=
```
>>>2<>3
SyntaxError: invalid syntax
>>2!=3
True
>>
```

9.5、编码问题

python2默认编码为ASCII，这就是为什么我们在编写代码出现中文时需要在第一行加上#coding=utf-8
```
>> import sys
>> sys. getdefaultencoding ()
ascii
```
python3默认编码为utf-8，因此python3不需要再出现中文时需要在第一行加上#coding=utf-8
```
import sys
>>sys. getdefaultencoding()
utf-8
```

9.6、与MySQL的交互

python2与MySQL进行交互时，需要安装MySQLdb，此外，python2与MySQL进行交互时，数据库密码为passwd=“密码”
而python3与MySQL交互时，需要安装的是pymsql，而python3与pymysql进行交互时，数据库密码为password=“密码”

9.7、urllib2与urrlib3

python2中urrlib2与urllib3都可以，爬虫时往往需要urllib与urllib2一起使用，因为urllib提供了urlencode()
而在python3中只能用urllib3，urllib2已经不能用了。爬虫时只需urllib3即可，因为python3默认编码为utf-8

9.8、ConfigParser.py与configparser.py

python2中ConfigParser.py模块作用是使配置文件生效
python3中ConfigParser.py改为了configparser.py,作用不变

9.9、Django中导入文件

如在django项目下的某一个应用中views需要导入本应用的models时，Python2
```
from models import *
```

Python3

from .models import * 或from应用名.mode1s import *

9.10、异常捕获

Python2中必须使用except…as…

print 'Python', python_version()
try:
 let_us_cause_a_NameError
except NameError, err:
 print err, '--> our error message'

Python3没有此要求

print('Python', python_version())
try:
 let_us_cause_a_NameError
except NameError as err:
 print(err, '--> our error message')

9.11、打开或创建文件

python2中可以使用open()或file()
python3中只可以使用open()

9.12、队列

python2中队列用的是Queue
python3中队列用的则是queue

9.13、多线程

python中使用的是thread模块
```
import thread
```
python3中改成了_thread或threading(推荐使用)
```
import _thread
import threading
```

9.14、加密

md5加密中，Python2使用import md5或者import hashlib；
```
import md5
import hashlib
```

而Python3只能使用import hashlib，使用方法hashlib.md5()。

import hashlib
import md5
Traceback (most recent call last)
File"<pyshell#1>, line 1, in <module>
    import md5
ImportError: No module named md5

9.15、cookielib与http.cookiejar

python2——使用cookielib包，然后使用CookieJar()方法创建一个cookie实例对象来保存cookie值
```
import cookielib
cookiejar = cookielib.CookieJar()
```
python3——使用的是http.cookiejar包，然后使用CookieJar()方法创建一个cookie实例对象来保存cookie值
import httpcookiejar
cookiejar = http.cookiejar.Cookiejar()

10、高阶函数

10.1、匿名函数

f = lambda x,y,z:x+y+z
def F(x,y,z):
    return x+y+z

f = lambda x:x if x % 2 != 0 else x + 100
print(f(10))                    # 110

10.2、三元运算

name = 'Tom' if 1 == 1 else 'fly'
print(name)
# 运行结果： Tom

10.3、filter

filter()函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。
最终一次性返回过滤后的结果
filter()函数中有两个参数：
- 第一个，自定函数名
- 第二个，需要过滤的列

利用filter、lambda表达式获取L1中元素小于33的所有元素

L1= [11,22,33,44,55]
a = filter(lambda x: x<33, L1)
print(list(a))

def F(x):
    if x<33:
        return x
b = filter(F,L1)
print(list(b))111

# 输入 '102304'  ==> ['1', '2', '3', '4']
L1= '102304'
a = filter(lambda x: x !='0', L1)
print(list(a))

10.4、map

第一个参数接收一个函数名，第二个参数接收一个可迭代对象

利用map，lambda表达式将所有偶数元素加100

# -*- coding:utf8 -*-
l1= [11,22,33,44,55]
ret = map(lambda x:x-100 if x % 2 != 0 else x + 100,l1)
print(list(ret))
# 运行结果： [-89, 122, -67, 144, -45]

# lambda x:x-100 if x % 2 != 0 else x + 100
# 如果 "if x % 2 != 0" 条件成立返回 x-100
# 不成立：返回 x+100
def F(x):
    if x%2 != 0:
        return x-100
    else:
        return x+100
ret = map(F,l1)
print(list(ret))

10.5、reduce

字符串反转

'''使用reduce将字符串反转'''
s = 'Hello World'
from functools import reduce

result = reduce(lambda x,y:y+x,s)
# # 1、第一次：x=H,y=e  => y+x = eH
# # 2、第二次：x=l,y=eH  => y+x = leH
# # 3、第三次：x=l,y=leH  => y+x = lleH
print( result )      # dlroW olleH

10.6、sorted

经典面试题列表排序

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
print( sorted(students, key=lambda s: s[2], reverse=False) )    # 按年龄排序
# 结果：[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

def f(x):
    # ('john', 'A', 15)
    return x[2]
print( sorted(students, key=f, reverse=False) )    # 按年龄排序

对字典的value排序

d = {'k1':1, 'k3': 3, 'k2':2}
# d.items() = [('k1', 1), ('k3', 3), ('k2', 2)]
a = sorted(d.items(), key=lambda x: x[1])
print(a)            # [('k1', 1), ('k2', 2), ('k3', 3)]

两个列表编一个字典

L1 = ['k1','k2','k3']
L2 = ['v1','v2','v3']
print( list(zip(L1,L2)))
# zip(L1,L2) : [('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')]
# dict( [('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')] )  = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

A.Monster

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python基础之常识概念

概念常识1、深浅拷贝1.1、copy与deepcopy(What)copy：不管多么复杂的数据结构，浅拷贝只会copy一层deepcopy：深拷贝会完全复制原变量相关的所有数据，在内存中生成一套完全一样的内容，我们对这两个变量中任意一个修改都不会影响其他变量2、垃圾回收机制2.1、引用计数原理当一个对象的引用被创建或者复制时，对象的引用计数加1；当一个对象的引用被销毁时，...
复制链接

扫一扫