Python 基础

最新推荐文章于 2022-10-24 14:35:34 发布

M4chael1

最新推荐文章于 2022-10-24 14:35:34 发布

阅读量127

点赞数

分类专栏： Python 文章标签： python 编程语言

原文链接：https://mofanpy.com/tutorials/python-basic/basic/

版权

Python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Python 基础

仅供个人学习
来源于莫凡Python：https://mofanpy.com/tutorials/python-basic/basic/ 侵删

基本使用

print 功能

>>> print(1)
1
>>> print("we're going to do something")
we're going to do something
>>> print('apple' + 'car')
applecar
>>> print('apple' + str(4))
apple4
>>> print(1+2)
3
>>> print(int('1') + 2)
3
>>> print(float('1.2') + 2)
3.2

基本数学运算

加减乘除
^ 与 **
- python用**代表平方
取余数 %
- 余数取整 //

变量variable

>>> a, b, c = 1, 2, 3

while 和 for 循环

while 循环

condition = 1
while condition < 10:
    print(condition)
    condition = condition + 1

# 死循环 Ctrl + C 终止程序
while True:
    print(condition)

for 循环

# 输出1-9
for i in range(1, 10):
    print(i)

range(start, stop, step)

数据类型

list

列表 list = [1, 2, 3]
tuple

元组 tup = (‘python’, 1.7, 64)
dict

dictionary 字典迭代过程中将key作为迭代的对象返回。字典中的key是乱序的。

顺序一致的字典：collections模块中的OrderedDict对象
```
dic{}
dic['lan'] = 'python'
dic['version'] = 3.7
dic['platform'] = 64
for key in dic:
    print(key, dic[key])
```
set

set 集合会去除重复项，输出结果不是按照输入的顺序。

s = set([‘python’, ‘python2’, ‘python3’,‘python’])

if 判断语句

if 判断

if x==y:
    print('x is equal to y')
# 判断相等用==，赋值用=

if else 判断

if condition:
    true
else:
    false

python 中没有 ? : : 三目表达式。可通过 if-else的行内表达式完成类似的功能。

var = var1 if condition else var2

如果 condition 的值为 True, 那么将 var1 的值赋给 var;如果为 False 则将 var2 的值赋给 var

if elif else 判断

if condition1:
    true1_expressions
elif condition2:
    true2_expressions
elif condtion3:
    true3_expressions
elif ...
    ...
else:
    else_expressions

函数

def函数

def function():
    a = 1
    return a

函数参数

def function(a, b):
    c = a + b
    return c
print(function(1, 2))

默认参数

def function(a = 1, b)  # 错误写法
def function(b, a = 1)	# 正确写法
# 在需要默认参数的地方用 `=` 号给定即可
# 注意所有的默认参数都不能出现在非默认函数的前面

可变参数

def report(name, *grades):
    total_grade = 0
    for grade in grades:
        total_grade += grade
    return total_grade

可将参数封装成一个list或tuple传入

这里使用可变参数用*号修饰，可变参数不能出现在特定参数和默认参数前面，因为可变参数会吞噬掉这些参数。

关键字参数

def func(name, **kw):
    print('name is', name)
    for k,v in kw.items(): 
        print(k, v)
func('Mike', age=24, country='China', education='bachelor')
# 这些参数在函数内部自动封装成一个字典(dict)

全局 & 局部变量

模块安装

安装：pip install numpy

更新：pip install -U numpy

读写文件

换行

\n

open 读文件方式

myFile = open('file.txt', 'w')  # w写，r读，a追加
myFile.write(text)				# 将text写入文件
myFile.close()					# 关闭文件

tab 对齐

\t 达到tab对齐效果

读文件

file.read()

读取文本的所有内容

file.readline()

读取一行

file.readlines()

读取所有行，返回list

Class 类

Class类

class Calculator:       #首字母要大写，冒号不能缺
    name='Good Calculator'  #该行为class的属性
    price=18
    def add(self,x,y):		# self为默认值
        print(self.name)
        result = x + y
        print(result)
    def minus(self,x,y):
        result=x-y
        print(result)
    def times(self,x,y):
        print(x*y)
    def divide(self,x,y):
        print(x/y)

""""
>>> cal=Calculator()  #注意这里运行class的时候要加"()",否则调用下面函数的时候会出现错误,导致无法调用.
>>> cal.name
'Good Calculator'
>>> cal.price
18
>>> cal.add(10,20)
Good Calculator
30
>>> cal.minus(10,20)
-10
>>> cal.times(10,20)
200
>>> cal.divide(10,20)
0.5
>>>
""""

class 类 init 功能

__init__可以理解成初始化class的变量，取自英文中initial 最初的意思.可以在运行时，给初始值附值，

运行c=Calculator('bad calculator',18,17,16,15),然后调出每个初始值的值。看如下代码。

这里的下划线是双下划线

class Calculator:
    name='good calculator'
    price=18
    def __init__(self,name,price,height,width,weight):   # 注意，这里的下划线是双下划线
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.we=weight
""""
>>> c=Calculator('bad calculator',18,17,16,15)
>>> c.name
'bad calculator'
>>> c.price
18
>>> c.h
17
>>> c.wi
16
>>> c.we
15
>>>
""""

input 输入

input()

score = int(input('please input your scor:\n'))

元组, 列表, 字典

元组、列表

Tuple

用小括号、或无括号来表述，是一连串有顺序的数字

Tuple定义后不可变，可嵌套

a_tuple = (1, 2, 3)
b_tuple = 1, 2, 3

List

同Tuple，但List是以中括号命名

可变，可嵌套

a_list = [1, 2, 3]
a_list.append(0) # 最后面追加
a_list.insert(1, 0) # 在位置1处追加0
a_list.remove(2) # 删除列表中第一个出现值为2的项
print(a[0])  # 显示列表a的第0位的值
print(a[-1]) # 显示列表a的最末位的值
print(a[0:3]) # 显示列表a的从第0位 到 第2位(第3位之前) 的所有项的值
print(a[5:])  # 显示列表a的第5位及以后的所有项的值
print(a[-3:]) # 显示列表a的倒数第3位及以后的所有项的值
print(a.index(2)) # 显示列表a中第一次出现的值为2的项的索引
a.count(-1) # 统计列表中某值出现的次数
a.sort() # 默认从小到大排序
a.sort(reverse=True) # 从大到小排序

多维列表

a = [1,2,3,4,5] # 一行五列

multi_dim_a = [[1,2,3],
               [2,3,4],
               [3,4,5]] # 三行三列

print(a[1])
# 2

print(multi_dim_a[0][1])
# 2

dictionary 字典

a_list = [1,2,3,4,5,6,7,8]

d1 = {'apple':1, 'pear':2, 'orange':3} # 字典是无序容器
d2 = {1:'a', 2:'b', 3:'c'}
d3 = {1:'a', 'b':2, 'c':3}

print(d1['apple'])  # 1
print(a_list[0])    # 1

del d1['pear']
print(d1)   # {'orange': 3, 'apple': 1}

d1['b'] = 20
print(d1)   # {'orange': 3, 'b': 20, 'apple': 1}

def func():
    return 0

d4 = {'apple':[1,2,3], 'pear':{1:3, 3:'a'}, 'orange':func}
print(d4['pear'][3])    # a

模块

import 模块

import time as t	# 需要加t.前缀来引出功能
from time import time, localtime	# 只import自己想要的功能.
from time import * 	#输入模块的所有功能

其他

continue & break

break：直接跳出循环
continue：跳出本次循环

try 错误处理

try:
    file=open('eeee.txt','r')  #会报错的代码
except Exception as e:  # 将报错存储在 e 中
    print(e)
    
    
try:
    file=open('eeee.txt','r+')
except Exception as e:
    print(e)
    response = input('do you want to create a new file:')
    if response=='y':
        file=open('eeee.txt','w')
    else:
        pass	# 空语句
else:
    file.write('ssss')
    file.close()
"""
[Errno 2] No such file or directory: 'eeee.txt'
do you want to create a new file:y

ssss  #eeee.txt中会写入'ssss'

zip

zip 接受任意多个（包括0个和1个）序列作为参数，合并后返回Tuple列表

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))  #需要加list来可视化这个功能
"""
[(1, 4), (2, 5), (3, 6)]
"""


for i,j in zip(a,b):
     print(i/2,j*2)
"""
0.5 8
1.0 10
1.5 12
"""

lambda

fun = lambda x,y : x+y, 冒号前的x,y为自变量，冒号后x+y为具体运算。

fun= lambda x,y:x+y
x=int(input('x='))    #这里要定义int整数，否则会默认为字符串
y=int(input('y='))
print(fun(x,y))

"""
x=6
y=6
12
"""

map

map是把函数和参数绑定在一起。

>>> def fun(x,y):
    return (x+y)
>>> list(map(fun,[1],[2]))
"""
[3]
"""
>>> list(map(fun,[1,2],[3,4]))
"""
[4,6]
"""

深拷贝 & 浅拷贝

1.赋值: 只是复制了新对象的引用，不会开辟新的内存空间。

并不会产生一个独立的对象单独存在，只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。

import copy
a = [1,2]
b = a
a.append(3)
print(a)
print(b)

2.浅拷贝: 创建新对象，其内容是原对象的引用。

3.深拷贝：和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。深拷贝出来的对象是一个全新的对象，不再与原来的对象有任何关联。

多线程

多线程 Threading 是一种让程序拥有分身效果. 能同时处理多件事情. 一般的程序只能从上到下一行行执行代码, 不过多线程 (Threading) 就能打破这种限制. 让你的程序鲜活起来.

多进程

多进程 Multiprocessing 能让电脑更有效率的分配任务给每一个处理器, 这种做法解决了多线程的弊端. 也能很好的提升效率.

Tkinter 窗口视窗

GUI 设计模块.

pickle 保存数据

保存

import pickle

a_dict = {'da': 111, 2: [23,1,4], '23': {1:2,'d':'sad'}}

# pickle 是一个变量到一个文件
file = open('pickle_example.pickle', 'wb')
pickle.dump(a_dict, file)
file.close()

提取

# 需要close()
file = open('pickle_example.pickle', 'rb')
a_dict1 = pickle.load(file)
file.close()

# 无需close()
with open('pickle_example.pickle', 'rb') as file:
    a_dict1 =pickle.load(file)

print(a_dict1)

set

set 最主要的功能就是寻找一个句子或者一个list当中不同的元素

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']

sentence = 'Welcome Back to This Tutorial'

print(set(char_list))
>>> {'b', 'd', 'a', 'c'}

print(set(sentence))
>>> {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'o', 'W', 'T', 'B', 'i', 'e', 'u', 'h', 'k'}

print(set(char_list+ list(sentence)))
>>> {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'd', 'o', 'W', 'T', 'B', 'i', 'e', 'k', 'h', 'u', 'b'}

添加元素

add添加某个元素，但不是所有元素都能添加的，比如一个列表。

unique_char = set(char_list)
unique_char.add('x')
# unique_char.add(['y', 'z']) this is wrong
print(unique_char)

# {'x', 'b', 'd', 'c', 'a'}

清除元素或 set

清除一个元素用 remove 或 discard

清除全部用 clear

unique_char.remove('x')
print(unique_char)
# {'b', 'd', 'c', 'a'}

unique_char.discard('d')
print(unique_char)
# {'b', 'c', 'a'}

unique_char.clear()
print(unique_char)
# set()

筛选

我们还能进行一些筛选操作, 比如对比另一个东西, 看看原来的 set 里有没有和他不同的 (difference). 或者对比另一个东西, 看看 set 里有没有相同的 (intersection).

unique_char = set(char_list)
print(unique_char.difference({'a', 'e', 'i'}))
# {'b', 'd', 'c'}   不同

print(unique_char.intersection({'a', 'e', 'i'}))
# {'a'}				相同

正则表达式

简单的匹配

pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(pattern1 in string)    # True
print(pattern2 in string)    # False

python 中的 re 模块。re.search() ：没找到返回None，找到返回match的object

import re

# regular expression
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(re.search(pattern1, string))  # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string))  # None

灵活匹配

使用特殊的 pattern 来灵活匹配需要找的文字.

如果需要找到潜在的多个可能性文字, 我们可以使用 [] 将可能的字符囊括进来. 比如 [ab] 就说明我想要找的字符可以是 a 也可以是 b. 这里我们还需要注意的是, 建立一个正则的规则, 我们在 pattern 的 “前面需要加上一个 r 用来表示这是正则表达式, 而不是普通字符串. 通过下面这种形式, 如果字符串中出现run或者是ran”, 它都能找到.

# multiple patterns ("run" or "ran")
ptn = r"r[au]n"       # start with "r" means raw string
print(re.search(ptn, "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 7), match='run'>

同样, 中括号 [] 中还可以是以下这些或者是这些的组合. 比如 [A-Z] 表示的就是所有大写的英文字母. [0-9a-z] 表示可以是数字也可以是任何小写字母.

print(re.search(r"r[A-Z]n", "dog runs to cat"))     # None
print(re.search(r"r[a-z]n", "dog runs to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(r"r[0-9]n", "dog r2ns to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='r2n'>
print(re.search(r"r[0-9a-z]n", "dog runs to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='run'>

按类型匹配

除了自己定义规则, 还有很多匹配的规则时提前就给你定义好了的. 下面有一些特殊的匹配类型给大家先总结一下.

\d : 任何数字
\D : 不是数字
\s : 任何 white space, 如 [\t\n\r\f\v]
\S : 不是 white space
\w : 任何大小写字母, 数字和 _ [a-zA-Z0-9_]
\W : 不是 \w
\b : 空白字符 (只在某个字的开头或结尾)
\B : 空白字符 (不在某个字的开头或结尾)
\ : 匹配 \
. : 匹配任何字符 (除了 \n)
^ : 匹配开头
$ : 匹配结尾
? : 前面的字符可有可无

# \d : decimal digit
print(re.search(r"r\dn", "run r4n"))           # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \D : any non-decimal digit
print(re.search(r"r\Dn", "run r4n"))           # <_sre.SRE_Match object; span=(0, 3), match='run'>
# \s : any white space [\t\n\r\f\v]
print(re.search(r"r\sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \S : opposite to \s, any non-white space
print(re.search(r"r\Sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \w : [a-zA-Z0-9_]
print(re.search(r"r\wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \W : opposite to \w
print(re.search(r"r\Wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \b : empty string (only at the start or end of the word)
print(re.search(r"\bruns\b", "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 8), match='runs'>
# \B : empty string (but not at the start or end of a word)
print(re.search(r"\B runs \B", "dog   runs  to cat"))  # <_sre.SRE_Match object; span=(8, 14), match=' runs '>
# \\ : match \
print(re.search(r"runs\\", "runs\ to me"))     # <_sre.SRE_Match object; span=(0, 5), match='runs\\'>
# . : match anything (except \n)
print(re.search(r"r.n", "r[ns to me"))         # <_sre.SRE_Match object; span=(0, 3), match='r[n'>
# ^ : match line beginning
print(re.search(r"^dog", "dog runs to cat"))   # <_sre.SRE_Match object; span=(0, 3), match='dog'>
# $ : match line ending
print(re.search(r"cat$", "dog runs to cat"))   # <_sre.SRE_Match object; span=(12, 15), match='cat'>
# ? : may or may not occur
print(re.search(r"Mon(day)?", "Monday"))       # <_sre.SRE_Match object; span=(0, 6), match='Monday'>
print(re.search(r"Mon(day)?", "Mon"))          # <_sre.SRE_Match object; span=(0, 3), match='Mon'>

如果一个字符串有很多行, 我们想使用 ^ 形式来匹配行开头的字符, 如果用通常的形式是不成功的. 比如下面的 I 出现在第二行开头, 但是使用 r"^I" 却匹配不到第二行, 这时候, 我们要使用另外一个参数, 让 re.search() 可以对每一行单独处理. 这个参数就是 flags=re.M, 或者这样写也行 flags=re.MULTILINE.

string = """
dog runs to cat.
I run to dog.
"""
print(re.search(r"^I", string))                 # None
print(re.search(r"^I", string, flags=re.M))     # <_sre.SRE_Match object; span=(18, 19), match='I'>

重复匹配

如果我们想让某个规律被重复使用, 在正则里面也是可以实现的, 而且实现的方式还有很多. 具体可以分为这三种:

* : 重复零次或多次
+ : 重复一次或多次
{n, m} : 重复 n 至 m 次
{n} : 重复 n 次

# * : occur 0 or more times
print(re.search(r"ab*", "a"))             # <_sre.SRE_Match object; span=(0, 1), match='a'>
print(re.search(r"ab*", "abbbbb"))        # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

# + : occur 1 or more times
print(re.search(r"ab+", "a"))             # None
print(re.search(r"ab+", "abbbbb"))        # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

# {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a"))        # None
print(re.search(r"ab{2,10}", "abbbbb"))   # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

分组

我们甚至可以为找到的内容分组, 使用 () 能轻松实现这件事. 通过分组, 我们能轻松定位所找到的内容. 比如在这个 (\d+) 组里, 需要找到的是一些数字, 在 (.+) 这个组里, 我们会找到 Date: 后面的所有内容. 当使用 match.group() 时, 他会返回所有组里的内容, 而如果给 .group(2) 里加一个数, 它就能定位你需要返回哪个组里的信息.

match = re.search(r"(\d+), Date: (.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group())                   # 021523, Date: Feb/12/2017
print(match.group(1))                  # 021523
print(match.group(2))                  # Date: Feb/12/2017

有时候, 组会很多, 光用数字可能比较难找到自己想要的组, 这时候, 如果有一个名字当做索引, 会是一件很容易的事. 我们字需要在括号的开头写上这样的形式 ?P<名字> 就给这个组定义了一个名字. 然后就能用这个名字找到这个组的内容.

match = re.search(r"(?P<id>\d+), Date: (?P<date>.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group('id'))                # 021523
print(match.group('date'))              # Date: Feb/12/2017

findall

前面我们说的都是只找到了最开始匹配上的一项而已, 如果需要找到全部的匹配项, 我们可以使用 findall 功能. 然后返回一个列表. 注意下面还有一个新的知识点, | 是 or 的意思, 要不是前者要不是后者.

# findall
print(re.findall(r"r[ua]n", "run ran ren"))    # ['run', 'ran']

# | : or
print(re.findall(r"(run|ran)", "run ran ren")) # ['run', 'ran']

replace

我们还能通过正则表达式匹配上一些形式的字符串然后再替代掉这些字符串. 使用这种匹配 re.sub(), 将会比 python 自带的 string.replace() 要灵活多变.

print(re.sub(r"r[au]ns", "catches", "dog runs to cat"))     # dog catches to cat

split

再来我们 Python 中有个字符串的分割功能, 比如想获取一句话中所有的单词. 比如 "a is b".split(" "), 这样它就会产生一个列表来保存所有单词. 但是在正则中, 这种普通的分割也可以做的淋漓精致.

print(re.split(r"[,;\.]", "a;b,c.d;e"))             # ['a', 'b', 'c', 'd', 'e']

compile

最后, 我们还能使用 compile 过后的正则, 来对这个正则重复使用. 先将正则 compile 进一个变量, 比如 compiled_re, 然后直接使用这个 compiled_re 来搜索.

compiled_re = re.compile(r"r[ua]n")
print(compiled_re.search("dog ran to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='ran'>

M4chael1

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Python 基础

Python 基础仅供个人学习来源于莫凡Python：https://mofanpy.com/tutorials/python-basic/basic/ 侵删基本使用print 功能>>> print(1)1>>> print("we're going to do something")we're going to do something>>> print('apple' + 'car')applecar>>>
复制链接

扫一扫