第一部分 运算符
运算符:有特殊计算规则的符号
运算数:参与运算的数字
几元运算:支持几元运算数,称为运算符是几元运算符
+ 二元运算符
-负数 一元运算符
表达式:由运算符和操作数结合起来组成计算式,表达式
1.算术运算符
+ - * / % // **
a=5
b=9
print(a+b,a-b,a*b,a/b)
% 求模:获得是余数,但方式math中的取余规则不一致
被除数=除数*商+余数
余数=被除数-除数*商
%求模 商 规则:向下取整
对于正数来说,求模过程算数运算中取余,得到余数
10-3*3=1
print(10%3)
对于负数来说
print(-10%3)
-10-3*(-4)=2
print(10&-3)
10-(-3)*(-4)=-2
取余(结果是浮点类型) math模块下fmod方法,商向0取整
import math
对于正数来说,求模和求余都是获得余数的过程(商都是向下取整)
print(math.fmod(10,3))
print(math.fmod(-10,3))
# -10-3*(-3)=-1
print(math.fmod(10,-3))
# -10-(-3)*(-3)=1
# 结论:
# 取余和模运算对于正数来说是一样的
# 对于负数来说,取模,商向下取整;取余,商向上取整
# 练习
# -7和-3 取模和取余
# print(math.fmod(-7,-3))
# print(-7%-3)
2.比较运算符(关系运算符):返回值是布尔类型True False
# == != 判断b和c 内容是不是相等
# 其他:!= <> < <= > >=
a=21
b=10
c=10
# print(a<b)
# print(a>b)
# print(a==c)
# print(a!=b)
# print(c==b) #判断b和c的内容是不是相等
# python支持链式比较
# python可以支持 0<a<b: 其他语言只支持0<a and a<b
3.身份运算符 is is not 判断对象是不是一致,(对象,是不是同样的内存地址)
a=21
b=21
# 因为数值21,是不可变类型,存在内存中之后,不能再修改。
# 对于不可变类型来说, is和 == 返回的值一致
# print(a==b)
# print(a is b)
# is 更严格,如果is返回的是True ==返回的一定是True
4. 逻辑运算符(布尔运算符)
# and与 or或 not非
# 操作数是布尔类型,运算符的两侧都是布尔类型
# and 与,当两侧的操作数都是True,返回True,如果有一侧为False则结果为False
print(True and True)
print(True and False)
print(False and False)
# or 或,只要有一侧是True,则结果为True,否则为False
# print(True or False)
# print(False or False)
# not 非,把当前的布尔值改变,如果原来是True,结果为False
print(not True)
# 应用来说,布尔类型值经常作为表达式出现
# print(3>1 and 5>2)
# print(3>1 and not 5>2)
# 所有的表达式最终得到数据类型,所有的数据类型都可以转换成布尔类型
# print(bool(7))
# print(bool(0))
# print(bool("aa"))
# print(bool(""))
# and 和 or 总是能返回两个表达式中的一个
# 对于and来说,第一个表达式如果是True,那么返回第二个表达式,否则是第一个表达式
# 对于or来说,第一个表达式是True,就返回第一个表达式,否则是第二个表达式
# print(3 and "abc")
# print(3-3 and 5>2)
# print(3 or "abc")
# 短路现象
# and,如果第一个表达式为假,后面的表达式不执行
# or , 如果第一个表达式为真,后面的表达式不执行
# x=0 and print("and中不执行")
# x=0 or print("or中不执行")
# x=1 or print("中不执行")
print("=========")
print(print("aaa") and print("bbb"))
# print("aaa") or print("bbb")
5.位运算符,返回的是十进制的数
# (1).原码、反码、补码
# 原码:二进制
# 反码: 原码的符号位不变,其余取反
# 补码:反码+1:计算机中存的就是补码
# 对于正数来说:原码、反码、补码是同一个数
# 对于负数来说:原码、反码、补码按如下计算
# 由 原码---补码和补码---原码,都是取反会加1
# & | ^ ~ << >>
# & 按位与: 如果都是1,则返回1,否则返回0
a=0b10011
b=0b01101
# 00001
print(a&b)
print(5&-1)
# 任何数跟所有位为1的数按位与(-1),结果都是原来的数(复数用反码计算)。
print(5&0b1111)
print(-5&-1)
# | 或:如果有一位是1,返回1,否则返回0
x = 0b00110110
y = 0b00111111
# 00111111
print(x|y)
# 如果是十进制,负数要取补码
x=5
y=-5
print(x|y)
# 异或^ 相同0 不同1
print(x^y)
# ~ 按位取反,包括符号位
print(~-5)
print(~0b11111101)
# 位移 <<左位移 右位移>>
# 左位移:右侧全部以0填充,每移动一位,相当于乘以2
x=-15
print(x<<1)
# 右位移:正数,补0,负数,补1, 每移动一位,相当于整除2
print(x>>2)
6. 赋值运算符
# =赋予
# += *= /= %= **= 所有的算术运算符都适用
a=2
a=a+1
#等价于
a+=1
print(a)
7. 成员运算符 in not in 返回值 True False
# 判断元素是否存在于序列中
a="abc"
print("a" not in a)
# 运算符优先级
# 算术运算符> 比较运算符 > 逻辑运算符 > 赋值运算符
# a+b*c 计算机体现的是结合性,不是运算性
# 总结:返回布尔类型
# 1.比较
# 2.逻辑 与 或 非 , 特例,如果两侧都是常数表达式,返回其中一个表达式
# 2 and 3
# True and True
# 3.成员运算符 in
# 4.身份运算符 is
--------------------------------------------------------------------------
第二部分 字符串 str
"""
字符串 str
字符串定义:一组字符组成的序列,每一个元素都是一个字符串
特点:字符串是不可变类型
"""
a="abc"
print(type(a))
1.字符串的创建
"""
单引号
双引号:功能跟单引号类似
三引号
"""
# 单引号和双引号
a="abc"
b='abc'
# 单引号和双引号交替使用,可以输出对方
print("ab'c")
# 三引号,可以将字符串中定义的换行直接输出
# 三引号不是注释,因为它可以被解释器解析。
c="""
我是中国人
我爱中国
"""
# 下面的\是续行符
d="我是中国人"\
"我爱中国"
print(d)
print(c)
2. 转义序列
# 掌握\n
s="abc\nde\nf"
print(s)
# \转义还是\,单引号双引号,转义\",,\'
print("i am \"ddd\"")
3.字符串的操作
"""
(1)运算符
(2)索引
(3)切片
"""
(1)运算符:+ * , in not in is is not < > == !=
# + 合并,不是原地合并,是新创建字符串
print("abc"+"def")
# * 重复
print("a"*10)
# in not in
print("abc" in "abcabcaaaa") # True
# is ==
# is 比较的是对象
# ==比较的是内容
print("aa" == "aa")
print("aa" is "aa")
# 比较运算:按照元素比较,从第0个元素开始。逐个比较
print("abc"<"bcd")
(2)索引:获取序列中的某一个元素
# 格式:变量[index] index 索引 正数(从左到右),负数(从右到左),0(第一个元素)
a="abcdefg"
print(a[5])
print(a[-2])
# print(a[100]) 如果索引超过范围,会报错
# index 的范围[-len(o),len(o)-1]
print(a[-7])
print(len(a))
#证明了字符串是不可变类型
# a[1]="new_b"
(3) 切片:
# 可以按照一定方式,获得一定区域中元素,获得多个元素
# 语法:变量[start:end:step]
# start: 起始位置 :>0 <0 =0,如果省略,默认是0
# end :终止位置 : >0 <0 =0,如果省略,默认是len(o)
# step: 步长: 获得元素的时候,间隔的单位,默认是1
# 正数 从左到右获取, 负数 从右到左获取
# 获取的元素包含start,不包含end
# 跟index索引不同的,start end 如果越界,不会报错
# 使用时,要注意,start end 的方向一定保持跟step方向一致
a="abvdefgijk"
print(a[3:6])
print(a[-8:-5])
print(a[:5])
print(a[2:])
print(a[5:2:-1])
print(a[0:5:2])
# 获得从前到后的所有元素
print(a[:])
# 逆序输出
print(a[::-1])
# 练习: 获得2018-05-11年月日,使用切片获取
a="2018-05-11"
print(a[:4]+"年"+a[5:7]+"月"+a[8:]+"日")
print(a[:-6]+"年"+a[-5:-3]+"月"+a[-2:]+"日")
4.字符串的方法
s="abcdabcdaaabbb"
1.count 统计参数在字符串中出现次数
# 第一个参数:要统计的字符串
# 第二个参数: start
# 第三个参数: end(不包括终止位置)
# 使用的时候,如果参数是一个子串,统计的字符有顺序
print(s.count("ab"))
print(s.count("ab",1,-2))
# 只有一个参数,代表start,默认end终止
print(s.count("ab",2))
2. index find
# 查找相关的字符串,返回位置
# 第一个参数: 要查找的串
# 第二个参数: 起始位置
# 第三个参数: 终止位置(不包含)
# 如果不输入start和end, 默认找的第一次出现的位置
s.index("bc")
s.index("bc",2,len(s))
s.index("bc",2)
# s.index("bcaaa") # index如果找不到子串会报错
# find函数使用方法跟index几乎一致,但是如果找不到子串,会返回-1
s.find("bcaaa")
3. rindex rfind
# 找到末次出现的位置,从右侧开始找
print(s.rindex("ab"))
# start end (不包含)
print(s.rindex("ab",2,10))
# print(s.rindex("bdasa") # rindex 找不到也会报错
# rfind 用法跟rindex 几乎一样,但是如果找不到,不会报错,返回-1
print(s.rfind("bdaaa"))
4. replace 替换
"""
第一个参数: old要查找的字符串
第二个参数:要替换成的字符串
第三个参数:要替换几次,不写几次,默认全部替换
count 指的是替换掉的最大次数,超过了,没关系,全部替换
替换的时候,从左往右
string修改的函数,都是新创建的字符串
"""
5. strip 去掉,剪切
# 参数: 要剪切掉的字符,如果不写,默认剪切空格
# 剪切是要注意,剪切的元素只要被参数包含,并且出现在字符串的两端,就会被剪切掉
s="abcdabcdaaababb"
print(s.strip("a"))
print(s.strip("ab")) # 会剪切掉两端的a和b
# rstrip 只剪切右侧
print(s.rstrip("ab"))
# lstrip 只剪切左侧
print(s.lstrip("ab"))
6. split 切割,返回列表。切割的字符没有了
s="a b c d e"
print(s.split())
# 如果被切的字符在两端,会切出空的字符串作为元素
s="akkkeaeeaooauuu"
print(s.split("a"))
# split 中的max参数是最大的切割次数,如果超过了,没关系
print(s.split("a",6))
splitlines 按照换行符进行切割
s="ab\nccc\nddd\nddd\ndd"
# keepends 是否保留换行符
# True 保留
# False不保留,默认
print(s.splitlines())
print(s.splitlines(True))
7. startwith :判断当前字符串是否已指定字符串开头,返回True,False
# 可以指定start end(不包含end),不指定默认从头到尾
print("abcdefg".startswith("abc"))
print("abcdefg".startswith("abc",1,7))
8. endwith: 判断当前字符串是否已指定字符结尾,返回True,False
print("abcdefg".endswith("fg"))
print("abcdefg".endswith("fg",1,7))
9. upper lower
print("abc".upper())
print("Abc".upper())
print("ABC".lower())
10. captical让首字母大写
print("abcde".capitalize())
11. patition
# 返回元组,元组中包含三个元素1,参数之前的内容,2参数本身3参数之后的内容
print("abcdefg".partition("cd"))
# 如果参数不存在在字符串中,那么会返回2、3为空字符串的元组
print("abcdefg".partition("cdc"))
12. 判断字符和数值
print("abc汉".isalpha()) #判断字符串是否是字符
print("a".isnumeric()) #判断字符串是否是数值,包含希腊字符、阿拉伯数字
print("123".isdigit()) #判断是不是数字
print("123".isdecimal()) #判断是不是十进制
13. 判断是否是合法的标识符
print("2a23".isidentifier())
14. 判断字符是不是都是大写,小写,空格
print("ABCa".isupper())
print("ABC".isupper())
print("abc".islower())
print(" ".isspace())
15. center 向两侧填充字符
print("hello".center(10,"*"))