第二天

Posted 2020-11-05 ztx695911088

第一部分  运算符

运算符：有特殊计算规则的符号
运算数：参与运算的数字
几元运算：支持几元运算数，称为运算符是几元运算符
+ 二元运算符
-负数 一元运算符
表达式：由运算符和操作数结合起来组成计算式，表达式

 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,"*"))