[Python知识库]Python笔记

Python笔记

安装python

官网

基础语法

设置编码方式

# coding=utf-8

注释

单行注释:
# 单行注释

多行注释: 三个单引号
'''
多行注释
'''

输出语句

语法

print()

默认以\n结尾

可以自定义结尾

print(’’, end=’’)

print()

# 输出数字
print(1)

# 输出字符串
print('字符串')
print("字符串")

# 输出含有运算符 表达式
print(3+1) # 4


# 将数据输出到文件中
fp = open('C:/Users/WZF/PycharmProjects/pythonProject/test.txt','a+') # a+为追加的写入方式
print('hello word',file=fp)
fp.close()

# print函数可传多个参数 会自动在中间添加空格
print('hello', 'word', '!') # 输出 hello word !

保留关键字

import keyword
print(keyword.kwlist)

输出:
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

变量

变量命名规则

规则

• 只能使用字母、数字、下划线_
• 不能以数字开头
• 不能使用保留字
• 严格区分大小写

变量定义

变量的组成

• 标识: 对象所存储的地址，可以通过id(obj)来获取
• 类型: 对象的数据类型,可以通过type(obj)来获取
• 值: 对象所存储的具体数据,使用print(obj)可以将值进行打印输出

name='wzf'
print('标识',id(name))		# 标识 3042687264560
print('类型',type(name))		# 类型 <class 'str'>
print('值',name)				 # 值 wzf

变量中实际储存的是id 内存分析图↓

数据类型

int 整数

• 整数的不同表示方式(打印时会自动格式化为十进制)
  • 默认存储10进制
  • 二进制
    • 以0b开头
  • 八进制
    • 以0o开头
  • 十六进制
    • 以0x开头

float 浮点型

• python中浮点数储存为float类型，不是十分准确
  • 例:1.1+2.2 => 3.30000000000003
  • 解决方法:
    • 引入decimal模块
    • from decimal import Decimal
    • Decimal(‘1.1’)+Decimal(‘2.2’)

bool 布尔类型

• 真True(代表1)
• 假False(代表0)
• 可以转为整数
  • True+1 = 2

str 字符串

• 单引号

  '单行字符串'
  '''
  多行字符串
  '''
  

• 双引号

  "单行字符串"
  """
  多行字符串
  """
  

类型转换

隐式类型的转换

• int + bool => int

  • 1+True
    • 2

• int + float => float

  • 1+1.0
    • 2.0

• float + bool => float

  • 1.0+True
    • 2.0

显示类型转换

• bool

bool()

bool(0)
>>> False
bool(1)
>>> True
bool(3)
>>> True
bool('')
>>> False # 空字符串转换为False
bool(' ')
>>> True # 其他非空字符串会被转换为True
bool([])
>>> False # 空列表会被转换为False
bool({}) # 空字典会被转换成False

• int

int()

int(False)
>>> 0
int(True)
>>> 1
int(0.6) # 向下取整
>>> 0
int('123')
>>> 123
int("123")
>>> 123

• float

float()

float(5)
>>> 5.0
float(False)
>>> 0.0
float(True)
>>> 1.0
float('123')
>>> 123.0

• str

str()

str(123)
>>> '123'

算术运算符

比较运算符

逻辑运算符

位运算

赋值运算符

运算符的优先级

分支语句

if

if 条件:
    语句组1
else:
    语句组2
    

if 条件1:
    语句组1
elif 条件2:
    语句组2
else:
    语句组

获取用户输入

text = input('提示语句')
num = int(input('提示语句'))

分支表达式(三元运算)

语法结构

x if 条件语句 else y

print('大于') if a > b else print('小于')

pass 语句

语句什么都不做，只是一个占位符，用在语法上需要语句的地方

作用

在搭建语法结构的时候起占位符的作用，适合在构建逻辑时使用，专注构建逻辑，后续再补充具体内容

a=20
if a > 20:
    pass
elif a < 20:
    pass
else:
    pass

循环语句

While

while 条件语句
	# 循环执行的语句

for in循环

特点

• in表达从(字符串，序列等)中依次取值，又称为遍历
• for-in遍历的对象必须是可迭代对象(比如字符串(一个一个遍历)，序列)

语法结构

for 自定义的变量 in 可迭代对象:
	循环体
for item in b:
    print(item)

如果不需要item可以写成_
for _ in b:
    print('test');

执行图

列表

列表的创建

方法一

使用方括号[]创建

lst = ['a','b','c',90,True]
# 列表中存储的是对象的引用(id)

方法二

使用内置函数list

lst = list(['a','b',100])

列表特点

• 按输入顺序存放
• 索引从0开始一一映射，负数索引访问0
• 数据可重复
• 任意数据类型
• 根据需要动态分配和回收内存

获取列表索引

.index()

如果有多个值则返回从左往右第一个值

注意:当找不到值时会报异常

.index()
lst = ['hello', 'word', 1
print(lst.index('hello')) # 0
       
 # 在范围内查找
.index('要查找的字符串',起始位置,结束位置)
print(lst.index('hello',0, 2)) # 0

列表切片

语法

• 列表名[start : stop]

• 列表名[start : stop : step]

  • step为正数
    • 从第一个开始到stop 列表名[: stop : step]
    • 从start开始到最后一个元素 列表名[start :: step]
    • 整个列表 列表名[::step]
  • step为负数
    • 从末尾开始到stop 列表名[: stop : step]
    • 从start开始到0 列表名[start::setp]

lst = ['hello', 'word', 100, 'a', 'b', 'c']
print(lst[0:3])     # ['hello', 'word', 100]
print(lst[0:6:2])   # ['hello', 100, 'b'] 从第一个开始到stop
print(lst[0::2])    # ['hello', 100, 'b'] 从start开始到最后一个元素
print(lst[::])      # ['hello', 'word', 100, 'a', 'b', 'c'] 整个列表
print(lst[:3:-1])   # ['c', 'b'] 从末尾开始到stop
print(lst[3::-1])   # ['a', 100, 'word', 'hello'] 从start开始到0

列表元素增删改查操作

列表查询

语法

判断指定元素在列表中是否存在

• 元素 in 列表名

• 元素 not in 列表名

列表元素的遍历

for 迭代变量 in 列表名

添加

语法

lst = ['hello', 'word', 100, 'a', 'b', 'c']
lst.append('d')
print(lst)                      # ['hello', 'word', 100, 'a', 'b', 'c', 'd']
lst.insert(1, 'test')
print(lst)                      # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd']
lst.extend(['e', 'f', 'g'])
print(lst)                      # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g']
lst = lst + ['h']
print(lst)                      # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst = lst * 2
print(lst) 		# ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst.append(['i', 'j', 'k'])		# 当元素为列表时，整个列表视为一个一个元素(一个整体)
print(lst)      # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', ['i', 'j', 'k']]
# 切片添加
lst[1:] = ['aaa']
print(lst)

删除操作

lst1 = ['a', 'b', 'c', 'd', 'e', 'e', 'f']
print(lst1)         # ['a', 'b', 'c', 'd', 'e', 'e', 'f']
lst1.remove('b')
print(lst1)         # ['a', 'c', 'd', 'e', 'e', 'f']
lst1.pop(0)
print(lst1)         # ['c', 'd', 'e', 'e', 'f']
lst1[1:3] = []
lst1.clear()        # []
print(lst1)
del lst1
del lst1
# print(lst1) 报错

修改操作

lst2 = ['a', 'b', 'c', 'd', 'e', 'e', 'f']
print(lst2)
lst2[0] = 'a1'
print(lst2)                 # ['a1', 'b', 'c', 'd', 'e', 'e', 'f']
lst2[1:3] = ['new Item'] 
print(lst2)                 # ['a1', 'new Item', 'd', 'e', 'e', 'f']

排序

列表生成式

语法

[列表元素的表达式 for 自定义变量 in 可迭代对象]

• 例
  • [i for i in range(1,10)]

lst3 = [i for i in range(1, 10)]
print(lst3)     # [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst4 = [i * i for i in range(1, 10)] 
print(lst4)     # [1, 4, 9, 16, 25, 36, 49, 64, 81]

# 生成一个2 4 6 8 10的列表
lst5 = [i * 2 for i in range(1, 6)]
print(lst5)  # [2, 4, 6, 8, 10]

其他语法

list(range(1,10))

字典

概念

• 是Python内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无序的序列

字典的创建

语法

• 使用花括号创建

  dictionary = {'key1':100,'key2':90,'key3':80}
  

• 使用内置函数dict()

  dict()
  

例

dictionary = {'key1': 100, 0: 80, 'test': 90}
print(dictionary)  # {'key1': 100, 0: 80, 'test': 90}
dictionary1 = dict(key1=1, key2=2, kry3=3)
print(dictionary1)  # {'key1': 1, 'key2': 2, 'kry3': 3}

字典元素的获取

语法

• [key]
  • 如果字典中不存在指定的key，会抛出keyError异常
• .get(key)
  • 如果字典中不存在指定的key，返回None，也可以通过参数设置默认的value，以便指定的key不存在是返回
  • .get(key,defalut)

dictionary = {'key1': 100, 0: 80, 'test': 90}
print(dictionary)  # {'key1': 100, 0: 80, 'test': 90}
value1 = dictionary['key1']
print(value1)  # 100
value2 = dictionary.get('key2')
print(value2)  # None
value3 = dictionary.get('key4', '无')
print(value3)  # 无

字典的常用操作

key的判断

字典元素的删除

del dictionary['key1']

字典元素的新增

dictionary['newKey'] = newValue

获取字典视图

dictionary = {'key1': 100, 0: 80, 'test': 90}
keys = dictionary.keys()
print(keys)             # dict_keys(['key1', 0, 'test'])
print(list(keys))       # ['key1', 0, 'test']
values = dictionary.values()
print(values)           # dict_values([100, 80, 90])
print(list(values))     # [100, 80, 90]
items = dictionary.items()
print(items)            # dict_items([('key1', 100), (0, 80), ('test', 90)])
# items转换之后的列表元素由元组组成
print(list(items))      # [('key1', 100), (0, 80), ('test', 90)]

字典的遍历

for item in dictionary:
    print(item)	# 输出的是键
    # key1
	# 0
	# test

字典生成式

keys = ['key1', 'key2', 'key3']
values = [100, 90, 80]
d = {k: v for k, v in zip(keys, values)}
print(d) # {'key1': 100, 'key2': 90, 'key3': 80}

字典的特点

• 所有的元素都是一个key-value键值对，key不允许重复，value可以重复
• 字典中的元素是无序的
• 字典中的key必须是不可变对象
• 字典也可以根据需要动态的伸缩
• 字典会浪费较大的内存，是一种使用空间换时间的数据结构

元组

定义

python内置的数据结构之一，是一个不可变序列

• 不可变序列: 字符串，元祖
  • 没有增删改查，修改后内存地址发生改变，生成了全新对象
• 可变序列：列表，字典
  • 可以对序列执行增删改查，对象地址不发生更改

元祖的创建方式

直接使用小括号

t = ('a', 'b', 'c')
print(t)        # ('a', 'b', 'c')
print(type(t))  # <class 'tuple'>

**注意:**只包含一个元组的元素也需要使用逗号和小括号

t=(10,)

c = ('a')
print(c)        # a
print(type(c))  # <class 'str'>

c = ('a',)
print(c)        # ('a',)
print(type(c))  # <class 'tuple'>

省略小括号写法

t = 'a', 'b', 'c'	# 省略小括号写法
print(t)        # ('a', 'b', 'c')
print(type(t))  # <class 'tuple'>

**注意:**只包含一个元组的元素也需要使用逗号

t=10,

使用内置函数tuple()

t = tuple(('a', 'b', 'c'))
print(t)        # ('a', 'b', 'c')
print(type(t))  # <class 'tuple'>

空元组

t=()
t=tuple()

注意

• 元祖中存储的是对象的引用
  • 如果元祖中对象本身是不可变对象，则不能再引用其他对象
  • 如果元祖中的对象是可变对象，则可变对象的引用不允许改变，但数据可改变

元祖中的列表或者字典或者集合中的元素可变

t = 'a', 'b', 'c', [1]
print(t)        # ('a', 'b', 'c', [1])
t[3].append(2)
print(t)        # ('a', 'b', 'c', [1, 2])

元祖的遍历

使用索引访问元组

缺点：需要知道一共有多少索引

t=('a','b','c')

print(t[0])
print(t[1])
print(y[2])

使用for in访问元组

t=('a','b','c')
for i in t:
    print(i)

集合

定义

• 是Python语言提供的内置数据结构

• 与列表，字典一样都属于可变类型的序列

• 集合是没有value的字典

特点

• 元素不允许重复，会自动去除重复元素

• 元素无序

集合的创建

通过{}来创建

s = {2, 3, 4, 5, 6, 7, 8, 7, 7}
print(s)  # {2, 3, 4, 5, 6, 7, 8}

通过set()来创建

s1 = set([2, 3, 4, 5, 6, 7, 8])
print(s1)  # {2, 3, 4, 5, 6, 7, 8}
s2 = set((1, 2, 3))
print(s2)  # {1, 2, 3}
s3 = set('abcfawfsda')  # 无序
print(s3)  # {'f', 'w', 'd', 'c', 'b', 'a', 's'}
s4 = set({1, 2, 3, 4})
print(s4)  # {1, 2, 3, 4}

定义空集合

s5 = set()
print(s5)  # set()

**注意:**使用{}为空字典类型

集合的相关操作

集合元素的判断操作

in 或者 not in

集合元素的添加操作

集合的删除操作

集合之间的关系

集合的数学操作

运算	运算符号	功能	例	韦恩图
.intersection()	&	求A集合和B集合的交集	A.intersection(B) / A & B
.union()	|	求A集合和B集合的并集	A.union(B) / A | B
.difference()	-	求A集合和B集合的差集	A.difference(B) / A - B
.symmetric_difference	^	求A集合和B集合的对称差集	A.symmetric_difference(B) /A ^ B

集合生成式

语法

{集合元素的表达式 for 自定义变量 in 可迭代对象}

l = {i for i in range(1, 10)}
print(l)    # {1, 2, 3, 4, 5, 6, 7, 8, 9}

列表、字典、元祖、集合总结

字符串

定义

字符串是基本数据类型，是不可变的字符序列

字符串驻留机制

定义

仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时,不会开辟新空间，而是把该字符串的地址赋给新创建的
变量

驻留机制的几种情况**(交互模式，控制台中)**

• 字符串的长度为0或1是
  • 
• 符合标识符的字符串
  • 
• 字符串只在编译时进行驻留，而非运行时
  • 
  • 图中ab+c的操作是在编译时计算
  • .join([])的运算是在运行时计算，所以不会驻留
• [-5,256]之间的整数数字
  • 
  • 
• sys中的intern方法强制2个字符串指向同一个对象
  • 

**注意:**PyCharm对字符串进行了优化处理

s1 = "abc"
s2 = "abc"
print(s1 is s2)  # True
a = 'abc'
b = 'ab' + 'c'
c = ''.join(['ab', 'c'])
print(c)        # abc
print(a is b)   # True
print(a is c)   # False



# 特殊情况
# 此处与控制台结果不同，因为此处PyCharm对字符串进行了优化
s1 = "abc%"
s2 = "abc%"
print(s1 is s2)  # True
print(id(s1),id(s2))    #2011173562864 2011173562864

a = -100
b = -100
print(a is b)   # True 此处与交互式不同

优缺点

• 优点:
  • 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。
• 缺点
  • 在需要进行字符串拼接时建议使用 str类型的join方法，而非+ ,因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高

字符串的查询操作

字符串的大小写转换操作

常用函数

range()

作用

生成一个序列

特点

不管range对象表示的整数序列有多长，所有的range对象占用的内存空间都是相同的，因为仅仅需要存储start end 和 step ，只有当用到range对象时，才会去计算序列中的相关元素

可以通过in 与not in 判断整数序列中是否存在指定的整数

用法

• range(end)

range(10) # 生成一个从0-10的列表

b = range(10)
print(b)		# range(0, 10)
# list的作用是显示出列表
print(list(b))	# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• range(start , end)

range(1,10)

b = range(1, 10)
print(b)        # range(1, 10)
print(list(b))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

• range(start , end , step)

range(1,10,2)

b = range(1, 10, 2)
print(b)  		# range(1, 10, 2)
print(list(b))  # [1, 3, 5, 7, 9]