Sirius' blog
Sirius0v0
2020-05-14
目录

Python学习_基础语法（一）

{% note info %}

本篇非教程篇，是根据笔者自己的学习情况整理出来的小笔记，仅供读者阅读参考哦~

{% endnote %}

# 处理字符串

# 字符串的格式化

  • format方法

    '{<参数序号> : <格式控制标记>}'.format(<默认参数序号0、1、2>)
#格式控制标记：<所填充的字符> <对齐方式> <宽度> <,> <.精度> <类型> 


#说明：<对齐>：① < 左对齐 ② > 右对齐 ③ ^ 居中对齐
#	  <,>：	数字的千位分隔符
>>> '{0:=^20}'.format('python')
>>> '{0:*>20}'.format('bit')
'=======python======='
'*****************bit'

  • %方法

    username = xiaohong
PIN = 123456
'username:%s' % (username)
'PIN:%d' % (PIN)

# 运算与索引提取

x = 'I'
y = 'love'
z = 'u'

####	【运算】
#连接'+'
sentence = x + ' ' + y + ' ' + z
print(sentence)		#'I love u'
#复制'*'
copy = x*3
print(copy)			#'III'
#判断子串'in'
print(x in sentence)	#True

###		【索引】
print(sentence[3])		# o
print(sentence[2:5])	# lov          【左闭右开】
print(sentence[::-1])	# u evol I
print(sentence[5:2:-1])	# evo          【左闭右开】

# 进制与编码

函数名/操作 功能 实例
bin(x)或hex(x)或oct(x) 2、16、8进制转换(int to str) hex(1234) ==> 'ox4d2'
chr(u) 返回u(Unicode)对应的字符 chr(176) ==> '°'
ord() 返回字符对应的Unicode chr(‘°’) ==> 176
str.encode('编码') 编码
str.decode('编码') 解码

# 与大小写有关

函数名/操作 功能 实例
str.upper() 全部大写 'ada lovelace'.upper() ==> 'ADA LOVELACE'
str.lower() 全部小写 'ADa loveLAce'.lower() ==> 'ada Lovelace'
str.title() 首字母大写 'ada lovelace'.title() ==> 'Ada Lovelace'
str.capitalize() 第一个字符转换为大写 'how are u'.capitalize() ==> 'How are u'
str.swapcase() 大小写字母转换 'LaTex'.swapcase() ==> 'lAtEX'

# 拆分合并

函数名/操作 功能 实例
str.join(iter) 在iter每个元素之间添加字符 ‘=’.join('123') ==> '1=2=3'
str.strip(chars) 删除左右chars字符 '= python='.strip('= np') ==> 'ytho'
str.rstrip() 删除右边空白 ' Hello World '.rstrip() ==> ' Hello World'
str.lstrip() 删除左边空白 ' Hello World '.lstrip() ==> 'Hello World '
str.strip() 删除左右空白 ' Hello World '.strip() ==> 'Hello World'
str.split(sep) 按照sep进行分割为列表 ‘I love u’.split() ==> ['I','love','u']
.center(width[,fillchar]) 居中并填充 ‘python’.center(10,'=') ==> '==python=='

# 查找、替换字符串内容

函数名/操作 功能 实例
str.find('xx'[,start,end]) 查找字符串 ‘an apple’.find('a') ==> 0
str.rfind() (从右查找) 'an apple'.rfind('a') ==> 3
str.lfind() （从左查找） 略
str.index() （找不到报错） 略
str.rindex() 略 略
str.lindex() 略 略
str.replace(old , new) 替换字符串 'an apple'.replace('a','e') ==> 'en epple'

# 与判断相关

函数名/操作 功能 实例
str.startswith('str1') 判断str是否以str1开头 'filename.doc'.startswith('File') ==> False
str.endswith('str2') 判断str是否以str2结尾 'filename.doc'.endswith('txt') ==> False
str.isalpha() 判断是否是字母 'abcd6'.isalpha() ==> False
str.isdigit() 判断是否是数字 '2342'.isdigit() ==> True
str.istitle() 判断是否为标题式字符串 'Title Good'.istitle() ==> True
str.isupper() 判断是否都为大写 'ABCD'.isupper() ==> True
len(字符、列表、元组等) 返回对象长度 len(['23','awf','3fs','sdfsf']) ==> 4
str.count(sub) 统计字符串sub次数 ‘an apple a day’.count('a') ==> 4

# 处理列表

# 添加元素

函数名 说明
.append('string') 将元素 ‘string’ 添加到末尾
.insert(0 , 'string') 将元素 ‘string’ 添加到索引为 0 的地方
.extend(建议放含多个元素的列表) 类似于列表的合并【可以用'+'直接合并列表】

# 删除元素

函数名 说明
del list1[1] 知道元素位置时
.pop([1]) 提取一号位的元素，不传入参数时默认最后一个元素
.remove('string') 已知元素的值 'string' 时
.clear() 清除所有元素

# 组织列表

函数名 说明
.sort([reverse = True]) 永久性从小到大排序(传入参数从大到小)
sorted([reverse = True]) 临时性从小到大排序(传入参数从大到小)
.reverse() 永久性反转列表元素
enumerate(sequence[,start=0]) 将可遍历的对象组合为一个索引序列，多用于for循环当中
zip() 将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象
zip(*) 与 zip 相反，zip(*) 可理解为解压，返回元组类型

# 统计相关

函数名 说明
.count(x) 统计列表中x元素的个数

# 组合数据类型的处理

# 集合类型

  • 集合的特点：无序不重复
  • 集合的操作：并：S|TorS.union(T)，差：S-TorS.difference(T)，交：S&TorS.intersection(T)，补：S^T，判断子集：<=或<，判断包含：>=或>
  • 增强操作符：s|=T等。

# 声明集合

set1 = set()		#只能用此方法创建空集合
set2 = {1,3,7}		#set2 = {}不是集合而是字典类型
'''
字典：{key:value,key:value,......}
集合：{元素1,元素2,元素3,......}
'''

# 操作集合之增

方法 描述
s.add(x) 添加一个元素x
s.update() 添加多个元素

# 操作集合之删

方法 描述
s.remove() 移除x，若不存在，报错（KeyError）
s.pop() 随机取出一个元素(一般为第一个)，若S为空产生KeyError异常
s.clear 清楚所有元素
s.discard(x) 类似remove() 移除x，若不存在，不报错

# 操作集合之改

# 处理集合的方法

方法 描述
S.discard(x) 移除x，若不存在，不报错
S.clear()
S.copy() 返回一个副本
len(S) 返回元素个数
x （not）in S 判断x是否为S的一个元素

# 序列类型

  • 序列类型可分成：字符串类型，元组类型，列表类型
  • 序列可理解为可储存任何类型数据的列表，故大部分方法可适用于此（判断是否存在，连接，复制，索引，切片等）

# 补充方法

方法 描述
.index(x[,i,j]) 返回从位置i到位置j第一次出现x的位置
s.count(x) 返回s序列中出现x的总次数

# 元组类型

  • 定义：可使用（）；也可以不使用，用逗号分开，或tuple()
  • 创建后就不可以修改

内置方法tuple.count(x)和tuple.index(x)自行学习

# 可迭代类型的拆包与装包

当出现以下情况会报错：

t1 = (9,4,6,7)
x,y = t1

如下处理即可：

t1 = (9,4,6,7)
x,*y,z = t1			#x = 9, y = [4,6], z = 7
x,*y = t1			#x = 9, y = [4,6,7]
*x,y = t1			#x = [9,4,6], y = 7

* 的使用涉及到拆包与装包

给可迭代类型前加上星号（*）可代表将其拆分

将分散的值赋值给*变量可将其装包赋值给变量

def list_chai(a,*b):
    print(a,b)

>> list1 = [1,2,3,4]
>> list_chai(3,*list1)		# *list1 将列表拆开
	3 1 2 3 4

# 字典类型

定义：{}或dict()创建：{<键1>:<值1> , <键2>:<值2> , ... , <键n>:<值n>}

dict1 = {}
dict2 = dict()
dict3 = {'ID':'2020202020202','name':'xiaohong','age':18}
dict4 = dict([('name','lucky'),('age',18),(1,2)])

# 增加与更改元素

# 格式： dict5[key] = value
# 有key则更改值，无key则增加元素
dict5 = {}
dict5['brand'] = 'huawei'	#增加
dict5['brand'] = 'mi'		#更改

# 字典的查找判断

# dict1[key] 和 dict1.get(key) 均可以返回key对应的值
# 推荐dict1.get(key) 因为前者找不到key是会报错 后者会返回 None

# in 可用于字典中的判断存在操作 用于判断元素有没有在字典的key中出现
dict1 = {'brand':'huawei','name':'xiaohong'}
print('brand' in dict1)
方法 描述
d.items() 将字典转为列表包含元组的形式
d.keys() 查找字典的键，可以用for in 遍历
d.values() 查找字典的值，可以用for in 遍历
d.get(k[,default]) 返回字典中键k对应的值(找不到返回default)

# 字典中的删除

方法 描述
del dict1[key] 删除键为key的一对键值
d.pop(key[,default]) 根据key删除键值对，返回值（若无）为键的值（默认值）
d.popitem() 随机删键值对（一般是从末尾删），以元组类型返回被删除的键值对
clear() 同列表中的clear()，清空

# 字典中的其他内置函数

方法 描述
len(d) 返回字典中元素的个数
d1.update(d2) 将d2更新到d1中（合并：重key则以d2为准）
dict.fromkeys(seq[,value]) 创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

# 类型转换

  1. str --> int,list,set,tuple,float;
  2. 所有类型 --> str;
  3. list --> set,tuple,字典：[(key,value),(key,value),...];
  4. tuple,set,dict --> list;(字典转列表仅保存key)

# 其他函数

函数名 功能 实例
eval('string') 去掉最外侧引号 eval(‘1 + 3’) ==> 4
isinstance(变量，类型) 判断变量是否为某类型

# 操作数字

函数名 功能 实例
round(x , d) 对x四舍五入保留d位小数 round（0.1+0.2,1） == 0.3
divmod(x , y) 实现求商与余数 divmod(10,3) == (3,1)
pow(x,y[,z]) ( x ** y ) % z pow(3,pow(3,99),10000) == 4587

# 其他杂项

# 引入和调用库

import turtle as t
t.setup(500,500)	#推荐使用

'''
import turtle
turtle.setup(500,500)

from turtle import *
setup(500,500)
'''

# 条件结构

#二分支的紧凑结构
if <判断>:
    <表达式1>
else:
    <表达式2>
    
<表达式1> if <判断> else <表达式2>

# 异常处理

#当语句1发生错误的时候执行语句2
try:
    <语句1>
except [NameError]:			#仅名称错误时执行语句2
    <语句2>
    
#异常处理的高级情形
try:
    <1>
except:
    <2>
else:
    <3>				#当没有错误，继续执行3
finally:
    <4>				#无论有无错误，继续执行4

# 循环的拓展

#在for while之后可以加else进行拓展
for each in range(N):
    <...>
else:
    <...>
    
while <..>:
    <...>
else:
    <...>				#当循环中没有被break跳出循环，则执行else
编辑 (opens new window)
#Python
上次更新: 2023/08/09, 13:21:24
Python学习_运算符

Python学习_运算符→

最近更新
01
ipopt优化库配置及使用
07-21
02
ubuntu离线安装包的方法
07-21
03
其它控件的使用
03-05
更多文章>
Theme by Vdoing | Copyright © 2020-2024 Sirius0v0 | MIT License