Python基础知识总结

于 2019-08-12 11:33:21 发布
阅读量310 收藏
点赞数
分类专栏： Python 文章标签： Python知识总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/atoohoo/article/details/99292769
版权

python基础知识总结

基础语法

注释

字符串

运算符

变量

内置函数

控制流程

if/else

for循环

while

break

pass

continue

数据结构

列表list

元组tuple

字典dictionary

集合set

面向对象

封装

继承

多态

异常处理

好用的库

随机数

正则表达式

注释

使用’#’ 单行注释

使用’’’ ‘’'或这个""" “”" 多行注释

字符串

# 将首字母大写
stra = 'hello world!'
print(1,stra.capitalize())
# 替代字符串里面的字符
print(2,stra.replace('world','toohoo'))
strb = '\n\rhello world! \r\n'
# 分别去掉左边和右边的换行和回车
print(3,strb.lstrip())
print(4,strb.rstrip())
# 判断是否是以某个字符串开头或是结尾
strc = 'hello toohoo'
print(5,strc.startswith('hel'))
print(6,strc.endswith('oo'))
# 将字符串进行拼接
print(7,stra+strb+strc)
# 获取字符串的长度
print(8,len(strc))
# 将列表中的字符串进行拼接起来
print(9,'-'.join(['a','b','c']))
# 将字符串使用特定的字符进行分割
print(10,strc.split(' '))
# 在字符串中寻找子字符串,返回的是第一个找到的index
print(11,strc.find('ello'))

1 Hello world!
2 hello toohoo!
3 hello world! 


4 
hello world!
5 True
6 True
7 hello world!
hello world! 

hello toohoo
8 12
9 a-b-c
10 ['hello', 'toohoo']
11 1

运算符

# 常见的运算符
print(1, 1+2, 5/2, 5*2, 5-2)
# 布尔运算符True和False的首字母是大写的，not是小写的！
print(2, True, not True)
print(3,1<2,5>2)
# 移位运算,左移大，右移小
print(4,16>>3,2<<3)
# 或，与，异或
print(5,5|3, 5 & 3, 5 ^ 3)
# 输出类型
x = 2
y = 3.3
print(x,y,type(x),type(y))

1 3 2.5 10 3
2 True False
3 True True
4 2 16
5 7 1 6
2 3.3 <class 'int'> <class 'float'>

变量

不能以数字和运算符开头，0-9，±*/等，支持使用下划线开头等，不用定义类型，直接使用变量和名称即可

内置函数（buildinfunction）

print(1, max(1,3),min(2,1))
print(2, len('xxx'), len([1,2,3,4]))
print(3, abs(-2)) # fabs, Math.fabs
# 需要强转一下
lista = list(range(1,10))
print(4, lista)
# 输出list数据结构下面的函数方法
print(5, dir(list))
# 内置代码运行函数
x = 2
print(6, eval('x + 3'))
# 使用ASCII码转换函数
print(7,chr(65), ord('a'))
# divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
print(8,divmod(11,3))

1 3 1
2 3 4
3 2
4 [1, 2, 3, 4, 5, 6, 7, 8, 9]
5 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
6 5
7 A 97
8 (3, 2)

控制流程(controlflow)

# if else 语句
score = 65
if score > 99:
    print(1, 'A')
elif score > 60:
    print(2, 'B')
else:
    print(3, 'C')

# while流程控制
while score < 100:
    print(4, score)
    score += 10
score = 65

# for 循环
# for(int i = 0; i < 10; ++i)
# continue, break, pass
for i in range(0, 10, 2):
    if i == 0:
        pass # do_special
        # print(5, i)
    # 5之前的数字不输出
    if i <= 5:
        continue
    print(6, i)
    if i == 6:
        break

2 B
4 65
4 75
4 85
4 95
6 6

数据结构

列表list + 元组tuple

lista = [1,2,3] # vector<int> ArrayList
print(1, lista)
# 里面的数据是可以任意的
listb = ['a', 1, 'c', 1.1]
print(2, listb)
# 扩展
lista.extend(listb)
print(3, lista)
print(4, len(lista))
# 判断是否是列表里面的元素和列表相加
print(5, 'a' in lista)
lista = lista + listb
print(6, lista)
listb.insert(0, 'www')# 插入开头
print(7, listb)
listb.pop(1) # 弹出第一个元素"a"
print(8, listb)
# 反转列表b
listb.reverse()
print(9, listb)
listb.pop(1)
listb.pop(2)
print(10, listb[0], listb[1])
# 对列表b进行排序
listb.sort()
print(11, listb)
listb.sort(reverse = True)
print(12, listb)
# 元素扩容一倍
print(13, listb * 2)
print(14, [0]*14) # memset(src, 0, len)
# 元组不可改变
tuplea = (1, 2, 3)
listaa = [1, 2, 3]
listaa.append(4)
print(15, listaa)

1 [1, 2, 3]
2 ['a', 1, 'c', 1.1]
3 [1, 2, 3, 'a', 1, 'c', 1.1]
4 7
5 True
6 [1, 2, 3, 'a', 1, 'c', 1.1, 'a', 1, 'c', 1.1]
7 ['www', 'a', 1, 'c', 1.1]
8 ['www', 1, 'c', 1.1]
9 [1.1, 'c', 1, 'www']
10 1.1 1
11 [1, 1.1]
12 [1.1, 1]
13 [1.1, 1, 1.1, 1]
14 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
15 [1, 2, 3, 4]

字典dictionary

def add(a,b):
    return a + b

def sub(a,b):
    return a - b

dicta = {4:16, 1:1, 2:4, 3:9}
print(1, dicta)
print(2, dicta.keys(), dicta.values())
# python3中没有属性has_key，使用__contains__代替， 可以使用print(dir(dict))查看dict里面的方法属性
print(3, dicta.__contains__(1), dicta.__contains__('3'))
# 类似于 for map<int, int>::iterator it = x.begin(); it != x.end()
for key, value in dicta.items():
    print('key-value:', key, value)
# 使用对应的键值对，调用上面已经定义好的方法
dictb = {'+':add, '-':sub}
print(4, dictb['+'](1,2))
print(5, dictb['-'](15,3))
# 往字典中添加键值对，并输出对应的内容
dictb['*'] = 'x'
print(dictb)
# 弹出键为4的那个键值对
dicta.pop(4)
print(6, dicta)
# python3 不支持使用del删除键为1的键值对#del dict[1]会报错
print(7, dicta)

1 {4: 16, 1: 1, 2: 4, 3: 9}
2 dict_keys([4, 1, 2, 3]) dict_values([16, 1, 4, 9])
3 True False
key-value: 4 16
key-value: 1 1
key-value: 2 4
key-value: 3 9
4 3
5 12
{'+': <function add at 0x7fcea277aa60>, '-': <function sub at 0x7fcea277ad08>, '*': 'x'}
6 {1: 1, 2: 4, 3: 9}
7 {1: 1, 2: 4, 3: 9}

集合

lista = [1,2,3]
# 将列表和元组转换成为集合
seta = set(lista)
setb = set((2,3,4))
print(1, seta)
print(2, setb)
# 对seta和setb求交集和进行与运算
print(3, seta.intersection(setb), seta & setb)
# 对seta和setb求并集和进行union联合操作
print(4, seta | setb, seta.union(setb))
# 集合相减
print(5, seta - setb)
seta.add('x')
print(6, seta)
print(7, len(seta))
# 用于判断两个集合是否包含相同的元素，如果没有返回True，否则返回False(一个列表一个元组，所有返回False)
print(8, seta.isdisjoint(set((1,2))))

1 {1, 2, 3}
2 {2, 3, 4}
3 {2, 3} {2, 3}
4 {1, 2, 3, 4} {1, 2, 3, 4}
5 {1}
6 {1, 2, 3, 'x'}
7 4
8 False

面向对象

封装

继承

多态

class User:
    type = 'USER'
    
    def __init__(self, name, uid):
        self.name = name
        self.uid = uid
    
    #  默认的输出方法
    def __repr__(self):
        return 'im ' + self.name +' '+ str(self.uid)

class Guest(User):
    #  默认的输出方法
    def __repr__(self):
        return 'im guest:' + self.name +' '+  str(self.uid)

class Admin(User):
    type = 'ADMIN'
    
    # 继承USER，同时封装一个属性group
    def __init__(self, name, uid, group):
        User.__init__(self, name, uid)
        self.group = group
    
    #  默认的输出方法
    def __repr__(self):
        return 'im ' + self.name +' '+ str(self.uid) + ' ' + self.group
    
def create_user(type):
    if type == 'USER':
        return User('u1',1)
    elif type == 'ADMIN':
        return Admin('a1', 101, 'g1')
    else:
        return Guest('gu1',201)
        # raise ValueError('error')
        
if __name__ == '__main__':
    USER = 'USERX'
    user1 = User('u1',1)
    print(user1)
    admin1 = Admin('a1', 101, 'g1')
    print(admin1)
    print(create_user(USER))


im u1 1
im a1 101 g1
im guest:gu1 201

异常处理

try:
    print(2/1)
    print(2/0)
    # if type == 'c':
    #raise Exception('Raise Error', 'TooHoo') # 主动抛出异常，后面也能够接收
except Exception as e:
    print('error:',e)
finally:
    print('clean up')

2.0
error: division by zero
clean up

好用的库

随机数

import random
# 1-100范围
# random.seed(1) # 随机种子，限定是否随机和随机序列
# x = presx * 1000007 % xxxx
# prex = x 等幂性
print(1, int(random.random()*100))
print(2, random.randint(0,200))
print(3, random.choice(range(0,100,10)))
# 随机在0-100里面选出4个数
print(4, random.sample(range(0,100),4))
# 数字描述shuffle() 方法将序列的所有元素随机排序
a = [1, 2, 3, 4, 5]
random.shuffle(a)
print(5,a)

1 61
2 182
3 40
4 [12, 18, 40, 35]
5 [2, 5, 4, 1, 3]

正则表达式

特殊字符的含义:

实例描述
.匹配"\n"之外的任何的单个字符。要匹配包括’\n’在内的任何字符，可以使用’[.\n]'的模式。
\d匹配一个数字字符。等价于[0-9].
\D匹配一个非数字的字符。等价于[^0-9].
\s匹配任何空白的字符，包括空格、制表符、换页符等等。等价于[\f\n\r\t\v]。
\S匹配任何的非空白的字符。等价于[^\f\n\r\t\v]
\w匹配包括下划线的任何单词字符。等价于[A-Za-z0-9_]
\W匹配任何非单词字符。等价于[^A-Za-z0-9_]。

正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：

模式描述
^匹配字符串的开头
$匹配字符串的结尾
[…]用来表示一组字符串，单独列出：[amk]匹配’a’,‘m’或’k’
[^…]不在[]中的字符：例如[^abc]匹配除了a,b,c之外的字符
re*匹配0个或者多个的表达式，注意这里的re表示的是前面的字符串，改成ab*也是可以的
re+匹配1个或者多个的表达式
re?匹配0个或者1个由前面的正则表达式定义的片段，非贪婪方式
re{n}匹配n个前面表达式。例如，"o{2}“不能匹配"Bob"中的"o”,但是匹配"food"中的两个o。
re{n,}精确匹配n个前面的表达式。例如，"o{2,}“不能匹配"Bob"中的"o”,但是能匹配"foooood"中的所有的o。"o{1,}“等价于"o+”。"o{0,}“则等价于"o*”。
re{n,m}匹配n到m次由前面的正则表达式定义的片段，贪婪方式
ab
(re)匹配括号内的表达式，也表示一个组
(?imx)正则表达式包含三种可选标志：i,m或者x。只影响括号中的区域。
(?-imx)正则表达式关闭i,m或x可选标志。只影响括号中的区域。
(?:re)类似(…),但是不表示一个组
(?imx:re)在括号中使用i,m或者x可选标志
(?-imx:re)在括号中不使用i,m或者x可选标志
?#…注释.
(?=re)前向肯定界定符。如果所含正则表达式，以…表示，在当前位置成功匹配时成功，否则失败。但是一旦所含表达式已经尝试，匹配引擎根本没有提高，模式的剩余部分还要尝试界定符的右边。
(?!re)前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。
(?>re)匹配的独立模式，省去回溯
import re

# 正则表达式的正确打开方式：先用函数compile对正则表达式编译，然后使用findall函数进行查找

str = 'abc123def12gh15'
# 分组查找出字符串中一个或者多个数字字符串
p1 = re.compile('[\d]+')
# 找出字符串中所有的数字
p2 = re.compile('\d')
print(1,p1.findall(str))
print(2,p2.findall(str))
# \t\n
str = 'a@163.com;b@gmail.com;c@qq.com;e0@163.com;z@qq.com'
# 找出字符串中的邮箱，@前面是word一个或者多个，后面的是163或者qq一个或者多个最后匹配.com
p3 = re.compile('[\w]+@[163|qq]+\.com')
print(3,p3.findall(str))
#正则表达式解析html中的内容
str = '<html><h>title</h><body>xxx</body></html>'
# 匹配不是已左尖开头的h标签中的内容，包括h标签
p4 = re.compile('<h>[^<]+</h>')
print(4,p4.findall(str))
# 匹配括号内的表达式，也表示一个组
p5 = re.compile('<h>([^<]+)</h><body>([^<]+)</body>')
print(5,p5.findall(str))

# 匹配时间
# 方法一
str = 'xx2016-06-11yy'
p6 = re.compile('\d\d\d\d-\d\d-\d\d')
print(6,p6.findall(str))
# 方法二
p7 = re.compile('\d{4}-\d{2}-\d{2}')
print(7,p7.findall(str))

1 ['123', '12', '15']
2 ['1', '2', '3', '1', '2', '1', '5']
3 ['a@163.com', 'c@qq.com', 'e0@163.com', 'z@qq.com']
4 ['<h>title</h>']
5 [('title', 'xxx')]
6 ['2016-06-11']
7 ['2016-06-11']

待更新~

瓦雪子
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值