Python基础知识点及运用方法
一、变量
变量：’装’程序中的数据
变量名—- 标识符： 是独一无二的
1.标识符可以由字母、数字、下划线（_)组成，其中数字不能打头
2.标识符不能是Python关键字，但可以包含关键字
3.标识符不能包含空格
赋值：将数据放入变量的过程
name = 1 # name 就是变量名又称标识符，1 是变量名的赋值
print(name)
二、运算
运算中的类型
1. + —- 加法运算
a = 1
b = 2
c = a+b
print(c)
2. — —- 减法运算
a = 3
b = 2
c = a-b
print(c)
3. * —- 乘法运算
a = 3
b = 2
c = a*b
print(c)
4. / —- 除法运算
a = 4
b = 2
c = a/b
print(c)
5. % —- 取余运算
a = 4
b = 3
c = a%b
print(c)
1 # 这里为什么会是 1 呢，因为3不能被整除，还有余数1
a = 4
b = 2
c = a%b
print(c)
0 # 能被整除时，余数就是0呢
6. ** —- 幂运算（平方）
a = 2
b = 2
c = a**b
print(c)
4 # 2平方 2*2=4
a = 2
b = 4
c = a**b
print(c)
16 # 2的4次方 2*2*2*2=16
7. // —- 整除运算 向下取整
a = 3
b = 2
c1 = a/b
c2 = a//b
print(c1)
1.5 # 不能被整除时，会有小数点
print(c2)
1 # 但在整除运算时，会把小数点去掉，只要整数
8. == —- 判断
a = 1
b = 1
print(a == b)
True # True 布尔值 判断 a 是否等于 b 是返回 True
a = 1
b = 2
print(a == b)
False # False 布尔值 判断 a 是否等于 b 不是返回 False
9. round() —- 取整 四舍五入
a = 7
b = 5
c = a/b
print(round(c))
1 # 7/5 = 1.4 不能被整除，舍掉小数0.4 向下取整
a = 7
b = 4
c = a/b
print(round(c))
2 # 7/4 = 1.75 不能被整除，大于0.5 向上取整
a = 1
b = 2
d = 10
c = a/b
e = a/d
print(round(c))
0
print(round(e))
0 # 当分子为1时 不会四舍五入取整，会直接取值为0
10. math —- 函数模块
import math
a = 6.6
b = math.ceil(a)
c = math.floor(a)
print(‘向上取整为’, b)
向上取整为 7 #向上取整数为 7
print(‘向下取整为’, c)
向上取整为 6 #向下取整数为 6
#这里不管小数点后面的大小
网上查找到的一些math函数模块运用方法
d = 3
e = math.sqrt(d)
print(‘平方根的值为’, e)
1.7320508075688772
f = math.exp(d)
print(‘e的N次幂的值为’, f)
20.085536923187668
g = 625
h = 5
i = math.log(g,h)
print(‘对数计算的值为’, i)
4.0
11. decimal —- 模块 精度计算
import decimal # 数值需要传入字符串中，未放入字符串的会同下方一样
a = decimal.Decimal(‘2.2’)
b = decimal.Decimal(‘2.0’)
c = a-b
print(decimal.Decimal(c))
0.2
import decimal #只是用decimal模块来计算时，会精确到小数点后50位数
a = 2.2
b = 2.0
c= a-b
print(decimal.Decimal(c))
0.20000000000000017763568394002504646778106689453125
三、数值类型
1. int —- 整数
1， 2， 3， 4， 5 # 整数类型
1
2. float —- 浮点数
0.5, 1.1, 3.6, 7.7 # 浮点数类型
1
3. bool —- 布尔值
bool: Ture(1) False(0) # 在布尔值中只有两种方式，所对应的就是1和0
1
4. complex —- 复数
complex(1+2j) # 前面的1是实部，后面的2j是虚部，加起来就是一个复数
1
5. type —- 查看数据类型 注：重点 重点 重点 一个常用的类型
print(type(1))
<class ‘int’> # 1 是一个整数类型
print(type(2.5))
<class ‘float’> # 2.5 是一个浮点数类型
print(type(Ture))
<class ‘bool’> # Ture 是一个布尔值类型
print(type(‘1’))
<class ‘srt’> # 1 在这里是一个字符串类型
四、数据类型
1. srt —- 字符串
‘’ —- 单引号
“” —- 双引号
“””””” —- 三引号 在没有变量命名时可作为注释使用
字符串的基本方法： 增 删 改 查
⑴. 增
字符串拼接： + 拼接符
a = ‘风陨’
b = ‘老师’
c = ‘很帅’
d = a + b +c
print(d)
风陨老师很帅 #输出结果
⑵. 删
replace 替换 使用方法 重点 重点 重点
A = ‘adfhkmaehfd’
B = ‘adfhkmaehfdadfhkmaehfd’
print(A.replace(‘d’, ”))
print(B.replace(‘d’, ”))
afhkmaehf
afhkmaehfafhkmaehf #*参数’d’为赋值里待删除参数，第二参数”里无任何对像时在原有的赋值里删除所有待删参数
print(A.replace(‘d’, ‘ ‘))
print(B.replace(‘d’, ‘ ‘))
a fhkmaehf
a fhkmaehf a fhkmaehf # 第二个参数为空格时，赋值里待删除参数替换为空格
print(A.replace(‘d’, ‘帅’, 1))
print(A.replace(‘d’, ‘帅’, 2))
print(B.replace(‘d’, ‘帅’, 1))
print(B.replace(‘d’, ‘帅’, 3))
a帅fhkmaehfd
a帅fhkmaehf帅
a帅fhkmaehfdadfhkmaehfd
a帅fhkmaehf帅a帅fhkmaehfd # 第三个参数为，赋值里待删除替换参数的替换次数
⑶. 改
upper —- 改大写 针对的是字母
a = ‘ddhf’
b = ‘1235’
c = ‘小星星’
print(a.upper())
print(b.upper())
print(c.upper())
DDHF #输出结果：全部改成了大写字母
1235 #输出结果：当是数字时无任何变化
小星星 #输出结果：当是文字时无任何变化
lower —- 改小写 针对的是字母
a = ‘FdHk’
print(a.lower())
fdhk #输出结果：全部改成了小写字母
capitalize —- 首字母大写
a = ‘year’
b = ‘new year’
print(a.capitalize())
print(b.capitalize())
Year
New year #输出结果：首字母改成了大写，第二个单词仍然是小写字母
title —- 每个单词首字母大写
a = ‘year’
b = ‘new year’
print(a.title())
print(b.title())
Year
New Year #输出结果：每个首字母单词改成了大写
split —- 切割
a = ‘new year’
print(a.split(‘e’))
[‘n’, ‘w y’, ‘ar’] #输出结果：显示待切割参数删除，余下切割分离留下的参数
strip —- 去空格
b = ‘ new year ‘
print(b.strip())
print(b.lstrip())
print(b.rstrip())
new year #去掉开头和结尾空格
new year #去掉左边空格
new year #去掉右边空格 因空格无法完全显示出来，自己可以去验证下空格的位置
⑷. 查
索引切片：
下标：位置从*个开始 编号从0开始 特性：左闭右开
先切片，给下标，索引位置
a = ‘1 2 3 4 5 6 7 8 9 0 a b c d’
下标编号： 0 1 2 3 4 5 6 7 8 9 10 11 12 13……以此类推
count —- 查次数 重点 重点 重点
a = ‘hhgauehjdiosdhieh’
print(a.count(‘h’))
5 #输出结果：显示待查参数’h’出现5次
a = ‘hhgauehjdiosdhieh’
print(a.count(‘h’, 4, 14))
2 #输出结果：
#*参数待查’h’出现2次,
#第二参数’4’为待查参数下标位置第4位参数’u’开始
#第三参数’14’为待查参数下标位置第14位参数’i’结束
index —- 查下标 左边开始查，查到*个就结束 ，如果找不到就报错 重点 重点 重点
a = ‘gauehjdhhiosdhieh’
print(a.index(‘h’))
4 #输出结果：当参数待查’h’下标位置在赋值中的第4个位置,
a = ‘hhgauehjdiosdhieh’
print(a.index(‘h’, 5, 14))
6 #输出结果：
#*参数为待查参数’h’
#第二参数’5’为待查参数在赋值中下标位置第5位开始
#第三参数’14’为待查参数在赋值中下标位置第14位结束
a = ‘gauejdiosdie’
print(a.index(‘h’))
Traceback (most recent call last):
File “D:/Python/Python_notebook/课堂笔记/学习Python第二课3.26.py”, line 110, in <module>
print(a.index(‘h’))
ValueError: substring not found
#输出结果：当参数待查’h’不在赋值中时就会报错
find —- 查下标 左边开始查，查到*个就结束 ，如果找不到不报错
a = ‘gauejdhiosdhieh’
print(a.find(‘h’))
6 #输出结果：当参数待查’h’下标位置在赋值中的第6个位置,
print(a.find(‘h’, 3, 13))
6 #输出结果：当参数待查’h’下标位置在赋值中的第6个位置,
#*参数为待查参数’h’
#第二参数’3’为待查参数在赋值中下标位置第3位开始
#第三参数’13’为待查参数在赋值中下标位置第13位结束
print(a.find(‘z’))
-1 #输出结果：当参数待查’z’在赋值中没有时，不会报错，但会显示-1结果，这个根计算机系统有关
#在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
#在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
#long(长整型) 跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
#注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。（网络查找资料，有待查证，如有问题，请告知，谢谢！）
isdigit —- 判断是否为纯数字
a = ‘1256’
b = ’12ssd’
print(a.isdigit())
True #输出结果：a变量中的赋值是纯数字
print(b.isdigit())
False #输出结果：b变量中的赋值不是纯数字
isalpha —- 判断是否为纯字符
a = ‘1256’
b = ’11ssd’
c = ‘星星*棒’
print(a.isalpha())
False #输出结果：a变量中的赋值不是纯字符
print(b.isalpha())
False #输出结果：b变量中的赋值不是纯字符
print(c.isalpha())
True #输出结果：c变量中的赋值是纯字符
starwith —- 判断开始
a = ’23kjidheyghg’
b = ‘kjidh23eyghg’
print(a.startswith(’23’))
True #输出结果：判断a变量中的赋值’23’是开始的
print(b.startswith(’23’))
False #输出结果：判断b变量中的赋值’23’不是开始的
endswith —- 判断结束
a = ’23kjidheyghg’
b = ‘kjidh23eyggh’
print(a.endswith(‘g’))
True #输出结果：判断a变量中的赋值’g’是结束的
print(b.endswith(‘g’))
False #输出结果：判断b变量中的赋值’g’不是结束的
islower —- 判断全为小写
a = ‘ddhf’
b = ‘AsfD’
c = ‘ASDFH’
print(a.islower())
True #输出结果：判断a变量中的赋值是全部为小写
print(b.islower())
False #输出结果：判断a变量中的赋值不是全部为小写
print(c.islower())
False #输出结果：判断a变量中的赋值不是全部为小写
isupper —- 判断全为大写
a = ‘ddhf’
b = ‘AsfD’
c = ‘ASDFH’
print(a.isupper())
False #输出结果：判断a变量中的赋值不是全部为大写
print(b.isupper())
False #输出结果：判断a变量中的赋值不是全部为大写
print(c.isupper())
True #输出结果：判断a变量中的赋值是全部为大写
