Python基础语法知识学习总结

变量和简单的数据类型

学习python也有一段时间了，一直都在看书，没有写总结，是时候写一篇，把学到的东西总结一下，也是一个检测。

1.1 变量的命名和使用

在python中使用变量时，需要遵循一些规则和指南。
变量名只包含字母、数字和下划线。变量名可以是字母和下划线开头，不能以数字开头，例如：a_1可以，1_a不可以
变量名不能包含空格，但可以使用下划线来分隔其中的单词
python中的关键字和函数名不能作为变量名，变量名应简短又具有描述性
应使用小写的Python变量名，慎用小写字母的I和大写字母的O,容易看错成1和0

1.2 注释

单行注释： # 注释内容
块/多行注释 三个单引号 或者三个双引号
‘’’
注释内容
‘’’
或者
“”"
注释内容
“”"

1.3 数据类型

int ：整数 像 1,2,3,… 等
float ：小数 3.14 ， 5.67，8.9 ；
complex ：复数 ， 复数类型 ，有实部和虚部 complex( ‘a+bj’) 。
字符串：以单引号 ’ 或双引号 "括起来的任意文本，如’abc’，“xyz”，“I’m OK”，‘I’m “OK”’
布尔值：要么是 True，要么是 False。注意首字母是大写的。
布尔值可以用 and，or 和 not 运算。
空值：是 Python 里一个特殊的值，用 None 表示。None 是一个特殊的空值，但 None不能理解为 0，因为 0 是有意义的。

1.3.1 数的运算

x + y ，x - y，x * y，x / y，x // y 加减乘除
x % y：求余
+x，-X 正负
abs(x) 求绝对值
int(x) 把x 转成int 类型
float(x) 把x 转成float 类型
divmod(x, y)： 返回两个值， x//y , x%y
pow(x, y)，x ** y：a的b次方

1.3.2 转义字符

\ 续行符
\n 换行符
\0 数字零，表示空
\t 水平制表符，用于横向跳到下一制表位
‘’ 双引号
’ 单引号
\ 一个反斜杠
\f 换页
\0dd 八进制数，dd代表字符，如\012代表换行
\xhh 十六进制数，hh代表字符，如\x0a代表换行

1.3.3 字符串类型str

3.1.2 字符串类型str
一般来说 有三种方式定义一个字符串 。 单引号， 双引号，和三单引号，三双引号，字符串用来表示一段文本信息，字符串是程序中使用的最多的数据类型

字符串常见方法：
str.capitalize() 这个方法 返回一个字符串 ， 这个字符串相对于str 开头第一个字符大写
str.title() 每个单词的首字母大写
str.encoding() 字符串可以进行编码，默认utf-8 编码，简单理解 字符串可以转换不同的编码格式
str.find() 寻找一个字符串 是否在 str 中 ，如果在 返回对应最小的位置的下标(位置)，如果没有找到 返回 -1
str.rfind() 寻找一个字符串 是否在 str 中 ，如果在 返回对应最大的位置的下标(位置)，如果没有找到 返回 -1
str.index 这个方法 和find 相似，唯一的区别是 当寻找的子串没有找到的时候会报错，抛出 ValueError的异常。
str.startswith(prefix) 判断 字符串 是否是prefix开头，返回 True ,False
str.endswith(suffix) 判断 字符串 是否是suffx 结尾返回 True ,False
len(s) 获取字符串的长度
str.replace(old, new[, count]) 返回一个 将old 替换为new 的一个字符串 ，如果 count 给定了值，只替换 count 次。如果没有 给定count 就是全部替换。
str.lstrip() 去掉 左边空格，返回一个字符串
str.rstrip() 去掉 右边空格，返回一个字符串
str.strip() 去掉 两边 边空格，返回一个字符串
str.upper() 转换为 大写,返回一个字符串
str.lower() 转换为小写，返回一个字符串
str.swapcase() 改变字符的大小写。原本大写字符 -> 小写字符；原本小写字符 变成 大写字符
str.join(iterable) 返回一个字符串，该字符串是可迭代的字符串的串联,有点抽象
str.count(sub [, start[, end]]) 在 [start,end ] 范围内寻找没有子串sub ,如果有的话，出现的次数。如果没有返回0 ， start ,end 如果不指定的话，默认搜索整个字符串的范围
合并（连接）字符串：python使用加号（+）来合并字符串
str.split(sep=None, maxsplit=-1) 分开的意思 拆分字符串,
参数sep 就是要分隔字符的标识，maxsplit 拆分的次数，默认值 是-1，就是尽可能大的次数拆分这个字符串。

1.3.2 转义字符

1.4 列表类型

列表list由一系列按特定顺寻排列得元素组成，在Python中，用方括号（ [ ] ）来表示列表，用逗号来分隔其中的元素， list 中可以存放 一系列的元素,可以是 str 类型，也可以是其他任何你想放入的类型都是可以的。

list 中每个元素都是有自己的位置信息的。
list 中的每个元素可以是不同的类型，比如 int ，float ,str ,list .
list 中 的元素是可以修改的 ，也是说list 中的元素可以被改变值的.
list 中没有一个元素也是可以的， 这个时候是空list .

1.4.1 列表操作

创建列表：nums = [] #空列表；nums =[1,2,3,4,5] #有元素的列表
访问列表元素：print(nums[0])，在python中，第一个列表元素索引为0，最后一个元素索引为-1
获取list的元素个数：len(nums)
遍历list中的元素：for num in nums:
修改list中的元素：nums[n] = x
在list中添加元素：nums.append(x),该方法将元素添加到列表末尾
在list中插入元素：nums.insert(n,x),使用insert()方法可以在列表的任何位置添加元素，需要指定新元素的索引和值
切片：nums[a:b] 是获取 a<= i<b 这一段索引的数据。左闭右开的区间。 当然也可以用负数索引
删除list中的元素：del list[i] 删除 索引为i的元素。 如果没有这个索引，会报错的 IndexError。
pop(index) 删除一个元素，可以指定一个索引位置删除 如果没有指定就删除最后一个，并且最后返回这个删除的元素,如果是一个 空的列表 那么 会抛出一个 IndexError .
remove (元素) 删除一个元素，如果这个元素不在list中会报错的， ValueError
清空列表：list.clear()

1.4.2 列表中常用的方法

排序 sort：默认是升序 ，也可以降序list.sort(reverse=True) , 注意这里也是原地排序，直接改变list中的元素位置。
nums= [3, 5, 2, 0, 8, 1, 4, 6, 7]
nums.sort()
[0, 1, 2, 3, 4, 5, 6, 7, 8]

nums.reverse()
[8, 7 ,6 ,5 ,4 ,3 ,2 ,1, 0]

合并两个列表extend：
nums = [1,2,3]
nums2 = [7,8,9]
nums.extend(nums2)
nums
[1, 2, 3, 7, 8, 9]

copy列表：
nums = [1,2,3]
nums.copy()
[1, 2, 3]
nums2=nums.copy()
nums2
[1, 2, 3]

遍历列表:
for list in lists:

创建数值列表：Python函数range()生成一系列的数字
for value in range(1,5):
print(value)
1
2
3
4
5
range()创建数字列表
numbers = list (range(1,6))
print(numbers)
[1, 2, 3, 4, 5]

指定步长：
numbers = list(range(2,11,2)):打印1~10内的偶数
[2, 4 ,6 ,8 ,10]

列表非常适合用于存储在程序运行期间可能变化的数据集，列表是可修改的。

1.5 元祖类型tuple

元祖是一种可以存放元素的一个容器，这点和list有点像。但元祖使用圆括号来标识。
元祖不可修改。
创建元祖：
t = ‘apple’,‘orange’,‘banana’
t = tuple()
t = (1,2,3,4,5)
创建只有一个元素的元祖时， 最后要加逗号：t = (1,)
t[0] = ‘one’
Traceback (most recent call last):
File “”, line 1, in
TypeError: ‘tuple’ object does not support item assignment
tuple内的元素不允许修改,上面的例子 0 号位置， ‘one’ 想要替换 0号位置的元素 是不允许的 。
但是如果 0 位置的元素本身是一个可变类型比如 list , 这个时候 list.append 就可以添加元素。
t[1] 的元素 是一个 list , 这个时候就可以调用list.append 来添加元素了 。

t = (1,[2,3,4],5,6)
t
(1, [2, 3, 4], 5, 6)

t[1]
[2, 3, 4]

t[1].append(‘new’)
t
(1, [2, 3, 4, ‘new’], 5, 6)

遍历元祖中的所有值：
t = (50,100)
for t1 in t:

元祖解包：把元素分到不同变量上面，这样就可以把元祖的元素取出来， 当然也可以用索引的方式。

1.6 字典 dict

在Python中，字典是一系列键-值对，每个键都与一个值相关联，字典是由 一对键值对来组成的 。d = {key:value} 字典里面的元素 一般用 key:value 这种形式来表示。与键相关联的值可以是数字，字符串，列表乃至字典。

定义一个字典：
person = {
‘name’: ‘aline’,
‘height’: 180,
‘hobby’: ‘song’,
‘weight’: 70
}
person
{‘name’: ‘aline’, ‘height’: 180, ‘hobby’: ‘song’, ‘weight’: 70}
person[’'name]
‘aline’
我们可以通过过名称(key), 获取我们想要的值。

1.6.1 字典的特点

字典是由键值对组成的， 对键的要求是一个不可变类型也行， 不是所有的类型都能作为键。
字典是可变类型，可以修改字典key对应的值 。但是key本身是不可变的。
字典是无序的，永远不要希望字典 key 按照一定顺序返回，即使你看起来是有序的，也不要依靠这个特性。

1.6.2 字典的操作

创建一个空字典：dict ={}
创建非空字典：dict_1 = {‘one’: 1, ‘two’: 2, ‘three’: 3}
添加键值对：dict_1['four: 4]
{‘one’: 1, ‘two’: 2, ‘three’: 3, ‘four’:4}
修改键值对的值：dict_1[‘one’]=11
{‘one’: 11, ‘two’: 2, ‘three’: 3, ‘four’:4}

遍历字典：
person = {
‘name’: ‘aline’,
‘height’: 180,
‘hobby’: ‘song’,
‘weight’: 70
}
for key in person:
print(key)

weight
name
height
hobby

遍历字典的 value：
for key in person.values():
print(key)

70
aline
song
180

同时遍历 key ,value 的值:
for key in person.items()
person(key)
weight 70
name aline
height 180
hobby song

1.6.3 字典的常用方法

获取字典长度,即字典中key 的个数 ,len():len(dict)
判断一个key ,是否属于字典中的 key:in , not in
‘five’ in d
False
‘four’ in d
True
‘aaa’ not in d
True
获取字典的keys, values ,k_v

p.keys()
dict_keys([‘weight’, ‘name’, ‘height’, ‘hobby’])

p.values()
dict_values([60, ‘frank’, 165, ‘swimming’])

p.items()
dict_items([(‘weight’, 60), (‘name’, ‘frank’), (‘height’, 165), (‘hobby’, ‘swimming’)])

删除一对键值对 pop ，popitem:
pop(key) 可以指定删除指定的key ,返回对应的value 值。 如果指定的key 不存在字典中，会报错 KeyError 的错误。
person.pop(‘name’)
‘aline’

popitem() 会随机返回一对键值对，(key,value) 是一个元祖 ，然后从字典中删除 。如果字典是空的，则会报错 KeyError
r = person.popitem()
print®
(‘hobby’, ‘swimming’)

拷贝字典：p2 = p.copy()
合并两个字典：dict.update(other_dict)
向字典中添加元素：直接赋值就可以了，如果没有key会创建一个新的键值对 。如果有会覆盖掉原来的键值对。

p
{‘weight’: 60, ‘name’: ‘frank’}

p[‘one’]=1
p[‘two’] = 2
p
{‘weight’: 60, ‘name’: ‘frank’, ‘one’: 1, ‘two’: 2}

获取字典的key 对应的值 get vs. []
关于字典获取值有两种方式 get [] 操作符来获取。
两种稍微有一点区别
如果是get 如果key 不在字典里面 get(key,default) 会返回 default .不会报错
[] 这种 获取的时候，如果 key 不在字典中 会报错KeyError

p
{‘weight’: 60, ‘height’: 165, ‘one’: 1, ‘two’: 2}

p.get(‘one’)
1

p[‘one’]
1

setdefault(key,default)
有的时候 我们想给字典设置一个默认值 ，如果key 已经存在了，那么使用现在已经有的值. 不会对字典有任何改变 ，同时返回这个字典 key对应的value
如果没有这个key, 那么把这个值 key=default 放到字典中 ,同时返回这个新设置的值 value .

p
{‘weight’: 60, ‘height’: 165, ‘one’: 1, ‘two’: 2}

p.setdefault(‘one’)
1

p.setdefault(‘one’,10)
1

p
{‘weight’: 60, ‘height’: 165, ‘one’: 1, ‘two’: 2}

p.setdefault(‘three’,3)
3

这里 three=3 放入到字典中了
p
{‘weight’: 60, ‘height’: 165, ‘one’: 1, ‘two’: 2, ‘three’: 3}

1.7 集合set

集合是可以存放 一种无序 ，不重复的元素的一种数据结构 。 如果理解了字典的结构，那么集合就很好理解了，
集合结构相当于字典中只有key ,没有value 的 这种结构。

来创建一个集合
s = {“one”, “two”, ‘three’, ‘four’, ‘five’}
可以使用大括号 { } 或者 set() 函数创建集合.
attrs = set([‘name’,‘gender’,‘hobby’])
注意：创建一个空集合必须用set() , 而不是 { }，因为 { } 是用来创建一个空字典。

1.7.1 集合的特点

无序性：集合的所有元素是无序的
s = {“one”, “two”, ‘three’, ‘four’, ‘five’}
for i in range(5):
print(f"第{i}次 打印s ={s}")

定义 set 的时候,是按照数字的顺序定义的，但是打印的时候却没有按照数字的顺序打印，如果 是list 肯定是按照定义的顺序打印的。
s = {“one”, “two”, ‘three’, ‘four’, ‘five’}
print(s)
{‘one’, ‘four’, ‘five’, ‘two’, ‘three’}

不可重复性：在集合中没有索引这个东西。 它并不能区别对待相同的元素，当我打印的时候只有一个one

我们知道在list 中元素是可以放任何类型的，并且可以是重复的元素。原因是在list中每个元素都会有一个 索引，通过索引找到这个元素，不论这个元素放在哪里 只要知道 这个元素的索引，我就可以获取到值。而在集合中 没有索引这个东西。 它并不能区别对待相同的元素

nums= [‘one’, ‘two’, ‘three’, ‘four’, ‘one’]
nums
[‘one’, ‘two’, ‘three’, ‘four’, ‘one’]

存入了 两个 one 元素
s = {‘one’, ‘two’, ‘three’, ‘four’, ‘one’}
s
{‘one’, ‘two’, ‘three’, ‘four’}

可变性：可以向集合里添加元素，修改元素

s = {‘one’}
s
{‘one’}

s.add(‘two’)
s
{‘one’, ‘two’}

1.7.2 集合常用方法

增删改查 ，集合运算
创建一个set
s = set([3,5,9,10])
s
{9, 10, 3, 5}
#创建一个唯一字符的集合
t = set(“Hello”)
t
{‘H’, ‘o’, ‘e’, ‘l’}
#也可以这样创建一个集合
#s = {3,5,9,10}
#创建一个空集合
s = set()

#添加元素
#如果 已经存在的元素,不会重新添加
s = {3,5,9,10}
s.add(5)
s
{9, 10, 3, 5}
s.add(66)
s
{66, 3, 5, 9, 10}
#判断一个元素是否在 集合可以用 in
5 in s
True
6 in s
False
66 in s
True
#求集合长度
len(s)
5
#删除元素集合中的一个元素

s.remove(66)
s
{3, 5, 9, 10}

#remove 删除一个不存在的元素 会报错 KeyError
s.remove(‘frank’)
Traceback (most recent call last):
File “”, line 1, in
KeyError: ‘frank’
#discard 也可以用来删除 元素, 如果不存在不会报错, 不会对集合做任何操作直接返回None.
#Remove an element from a set if it is a member.
#If the element is not a member, do nothing.

s = {3, 5, 9, 10}
s.discard(‘delete’)
s
{3, 5, 9, 10}

#集合的拷贝 s.copy 这是一个浅拷贝

s = set()
s.add(1)
s.add(10)
s.add(5)
s
{1, 10, 5}

s.add(7)
s
{1, 10, 5, 7}

s.copy()
{1, 10, 5, 7}

s2 = s.copy()
s2
{1, 10, 5, 7}

#集合运算里面 有交 并 补 差集 运算
s={1,2,3,4}
s2 = {3,4,5,6,7}
s,s2
({1, 2, 3, 4}, {3, 4, 5, 6, 7})
s
{1, 2, 3, 4}
s2
{3, 4, 5, 6, 7}
s& s2
{3, 4}
s.intersection(s2) # 交集
{3, 4}

s
{1, 2, 3, 4}

s
{1, 2, 3, 4}

s2
{3, 4, 5, 6, 7}

s.difference(s2) # 差集
{1, 2}

s - s2
{1, 2}
#集合的并集

s.union(s2)
{1, 2, 3, 4, 5, 6, 7}

s|s2
{1, 2, 3, 4, 5, 6, 7}
交集 s & s2 或 s.intersection(s2) 交集运算
差集 s - s2 或 s.difference(s2) 差集运算
并集 s |s2 或 s.union(s2) 并集运算
s.issubset(other) 判断 自己是不是 other 的子集.即判断 s <= other 返回 True or False
s.issuperset(other) 判断 s >= other 返回 True or False
s.pop () 随机删除集合中的元素 ,并且返回该元素 , 如果集合是空的,会抛异常KeyError

流程控制

2.1 if 语句

定义：
if 条件表达式:
pass #语句1
else:
pass #语句2
Python中根据条件测试的值为True还是False来决定是否执行if语句中的代码，如果条件测试的值为True，就执行紧跟在if后面的代码

num = 10
if num > 5:
print(“Hello World”)
else:
print(“Null”)
Hello World

如果条件中有多个分支, 用if_elifelse形式

2.2 for 语句

定义：
for 元素 in iterable :
pass
iterable 中文的意思可迭代对象 ， 在python基础的类型哪些是可迭代对象呢?
list ,tuple ,dict ,set ,str ，range() 都是可迭代对象 。

例：通过 for 来实现 99 运算表
for i in range(1, 10, 1):
for j in range(1, i + 1, 1):
print(f"{i}{j} = {i * j} ", end=’ ')
print()

2.3 while 语句

定义：
while 条件表达式:
pass

如果 条件表达式 为真值， 则进行 while 下面的pass的语句段，通常在pass 语句段里面要有能够改变条件表达值 ，真值的语句， 如果没有这个语句，一旦进入while ，永远退出不了 while 代码块

break 可以提前终止循环
break 语句的作用 就是提前跳出 for 循环，然后进入for 下面的打印 hello world 的语句。
如果有双层for 循环 ，只会跳出内部的for 语句
for i in range(5):
for j in range(5):
if j in {2, 4}:
break
print(f"i={i},j={j}",end=’ ')
print()
i=0,j=0 i=0,j=1
i=1,j=0 i=1,j=1
i=2,j=0 i=2,j=1
i=3,j=0 i=3,j=1
i=4,j=0 i=4,j=1

continue：continue是继续的意思， 也是流程控制的一个关键字，这里提前结束 本次循环，然后进入下次循环。

for i in range(5):
… if i in {2, 3}:
… continue
… print(f"i = {i}")
… print(‘hello world’)

i = 0
i = 1
i = 4
hello world

猜数游戏：每次要求输入一个数字， 这个数字要求 1-50 之间 ，计算机也随机从这里选择中一个数字，然后你猜一个数字,程序告诉你大了，还是小了， 来进一步猜测，直到你猜出结果。
from random import randrange
#记录猜的次数
count = 0
rand_nums = randrange(0, 51)
num = int(input("请输入你要猜的数字 [0-50]: "))
while True:
if num > rand_nums:
print(“猜的太大了。”)
num = int(input("请输入你要猜的数字 [0-50]: "))
elif num < rand_nums:
print(‘猜的太小了’)
count += 1
num = int(input("请输入你要猜的数字 [0-50]: "))
else:
count += 1
print(f’恭喜你，猜对了. 你一共猜了{count} 次’)
# 猜对了要终止 循环 条件
break**