1.变量的命名规则 (c1.py)
# 变量 (命名要求，可读性强)
# 1.规则
# 1.1首字符不能为数字
# 1.2可以包含 数字,字母,下划线 ,不能以数字开头
# 1.3系统中的关键字(系统中的关键字也叫保留关键字，例如：if，and，import等等),不能用在变量名里
# 1.4虽然type,print等 不是系统保留关键字，但如果将其作为变量(作为变量时，不报错)，就不能当函数方法使用了，禁止将其作为变量名使用
# type = 3
# print(type)
# 然后再将其作为判断数据方法使用就会报错
# print(type(type))
# 1.5区分大小写 (eg:a=1,A=1不同)
# 1.6Python中对变量没有类型限制
# (eg:a=1,a='1',a=[1,2],可以给一个变量赋不同类型的值；在其它的一些编程语言中，在变量定义时就得声明其类型)
# 所以Python也称为动态语言(和JavaScript有点类似)
# 1.7也会存在深浅拷贝
# 1.7.1值类型(int,float,str,tuple等,不可变)，浅拷贝
# 1.7.2引用类型(set,list,dict,可改变)，深拷贝
# a = [1,2]
# b = a
# a[0] = 2
# print(b)
# 1.7.3对于下例子中的a，并不是a改变了，而是生成了一个新的字符串，将这个新生成的字符串赋给a。可以通过id()来查看一下变量的内存地址
# a = 'hello'
# print(id(a)) # 31203824
# a = a + ' world'
# print(id(a)) # 31425584 (内存地址改变了)
# print(a) # hello world
# 1.7.4 list 和 tuple
# a = [1,2,3]
# print(id(a)) #1794696
# a[0] = 2
# print(id(a)) #1794696 (内存地址未改变)
# b = (1,2,3)
# b[0] = 2 # 这种写法就报错了，元组是不可变类型;同时对于不可变类型，也没有 . 操作符
# 对于可变类型list还可使用 . 操作符
# c = [1,2,3]
# c.append(4)
# print(c) #[1, 2, 3, 4]
# 1.7.5 对于大型项目，会存在相互调用，有些不想在别人调用时改变，就可使用tuple(一变就会报错)，更安全；如果需要动态改变，就用list
# a = (1,2,[1,2,3])
# print(a[1]) # 2
# print(a[2][2]) # 访问第三项里的3，使用双重下标
# # a[0] = 2 # 不能改变
# a[2][2] =2 # 可以改变list项中的某一项
2.Python运算符总括 (c2.py)
# Python运算符
# 1.算数运算符
print('hello '+'world')
print([1,2,3]*3)
print(3-1)
print(3/2)
print(3//2)
print(5%2)
print(2**2)
print(2**3)
print(2**4)
# 2.赋值运算符
# =
# +=
# *=
# /=
# %=
# **=
# //=
# 3.比较(关系)运算符
# ==
# !=
# >
# <
# >= (大于或者等于)
# <= (小于或者等于)
# 4.逻辑运算符
# and (且(与)，有一个为False则为False,否则为True)
# or (或，有一个为True则为True,否则为False)
# not (非,)
# 5.成员运算符 (一个元素是否在另一组元素里；返回值是bool类型)
# in
# out in
# 6.身份运算符 (如果两个变量取值相等，则is返回True)
# is
# is not
# 7.位运算符 (把数字当做二进制数进行运算)
# & (按位与)
# | (按位或)
# ^ (按位异或)
# << (左移动)
# >> (右移动)
# 8.优先级大方向 (最终的优先级顺序，可查百度(后须自己再验证一下，因为资料也不一定特别准))
# 算数(+,-,*,/,%,//,**) > 比较(关系,==,+=) > 逻辑(not > and > or)
3.Python运算符详解 (c3.py)
# 1.赋值运算符 (终点在赋值)
# c = 1
# c = c + 1
# print(c)
# 1.1其它语言中还有 c++(自增),c--(自减)运算符，但Python中没有
# c += 1
# print(c)
# a = 3
# b = 2
# b += a
# print(b)
# b -= a
# print(b)
# b *= a
# print(b)
# d = 2
# e = 3
# 1.2 d+e 和 d += e 的最大区别是，前者只运算(运算前后，各自变量的值不变)，后者不仅运算且赋值(运算过后d的值改变)
# 2.比较(关系)运算符 (最终返回一个bool值)
# 2.1 右结合 (首先b>=1为True,然后b+=True,即b=b+True,最后得到结果)
# b = 1
# b+=b>=1
# print(b) # 2
# 2.2字符串也可比较，比较的是ASCII码，获取字符的ASCII码可以通过 ord()获取
# print('a'>'b') #False
# print(ord('a')) # 97
# print(ord('b')) # 98
# print('abc'<'abd') # True (从前往后，c的ASCII码小于d的ASCII码)
# print([1,2,3]<[2,1,3]) #True (第一项的1小于后边第一项的2)
# print((1,2,3)<(2,1,3)) #True (第一项的1小于后边第一项的2)
# 3.逻辑运算符 (最终返回一个bool值)
# 3.1
# print(True and True) #True
# print(True and False) #False
# print(True or False) #True
# print(False or False) #False
# print(not False) #True
# print(not True) #False
# 其它类型和bool类型存在一个转化关系，虽然下边例子，得到一些结果
# print(1 and 1) #1
# print('a' and 'b') #b
# print('a' or 'b') #a
# print(not 'a') #False
# 3.2其它类型对应的bool类型
# int float 0 被认为False;非0 被认为True
# str 空字符串 被认为是False;非空字符串 被认为True
# list []空列表 被认为是False;非空列表 被认为True
# tuple,set,dict 遵循和列表相同的规则
# print([1] or []) #[1]
# print([] or [1]) #[1]
# print('a' and 'b') #b
# print('' and 'b') #''
# 3.3 and (返回)
# 第一项为真会看第二项
# 第一项为假直接返回第一项
# 第一项和第二项都为真，返回第二项
# print(1 and 0) #0
# print(0 and 1) #0
# print(1 and 2) #2
# print(2 and 1) #1
# 3.4 or (返回)
# 第一项为真直接返回第一项
# 第一项为假会看第二项
# 第一项和第二项都为真，返回第一项
# print(1 or 0) #1
# print(0 or 1) #1
# print(1 or 2) #1
# print(2 or 1) #2
# 4.成员运算符
# print(1 in [1,2,3,4]) #True
# print(6 in [1,2,3,4]) #False
# print(1 in (1,2,3,4)) #True
# print(1 in {1,2,3,4}) #True
# dict 中看的是key是否存在,不会检测value
# print('name' in {'name':'石敢当','age':18}) #True
# print(18 in {'name':'石敢当','age':18}) #False
# 5.身份运算符 (对象的三个特征：值，身份，类型) (在Python中一切皆对象)
# 5.1 如果两个变量取值相等，则is返回True
# a = 1
# b = 2
# c = 1
# print(a is b)
# print(a is c)
# 5.2 is 和 ==
# 5.2.1在某些情况结果相同，有些情况有一定区别
# 5.2.1 == 关系运算符比较的是两个变量的值是否相等；而is比较的是两个变量的身份(即id地址)是否相等
# a = 1
# b = 1
# c = 1.0
# print(a is b) #True (相同)
# print(a == b) #True (相同)
# print(a is c) #False (不同)
# print(a == c) #True (不同)
# print(id(1)) #8791043924816
# print(id(1.0)) #5615736
# 5.2.2
# a = {1,2,3}
# b = {2,1,3}
# print(a == b) #True (集合是无序的，顺序不影响值的大小比较)
# print(a is b) #False (is 是身份的比较，通过id获取，不同)
# print(id(a)) #31992968
# print(id(b)) #32047624
# c = (1,2,3)
# d = (2,1,3)
# print(c == d) #False (元组是序列，是有序的，书序会影响取值)
# print(c is d) #False (is 是身份的比较，通过id获取，不同)
# print(id(c)) #34693408
# print(id(d)) #34693624
# 5.3类型的判断
# 5.3.1通过 type 来判断 (不能判断子类，不太推荐)
# a = 'hello'
# print(type(a) == str) #True
# print(type(a) == int) #False
# 5.3.2通过 isinstance 来判断
# 5.3.2.1 isinstance(被判断的变量,类型)
# print(isinstance('hello',str)) #True
# 5.3.2.2 isinstance(被判断的变量,(类型1,类型2,类型3)) (后边接一个元组，满足其一即可)
# print(isinstance('hello',(str,int,bool,dict))) #True
# 5.3.3对象的三个特征(重要) (身份id,值value,类型type 分别对应三种运算关系 is，==,isinstance)
# 6.位运算符
# 6.1 按位与 &
# a = 2
# print(bin(a)) #0b10
# b = 3
# print(bin(b)) #0b11
# print(a & b) #ob10 (即转为十进制为2)
# 6.1 按位或 |
# a = 2
# print(bin(a)) #0b10
# b = 3
# print(bin(b)) #0b11
# print(a | b) #ob11 (即转为十进制为3)
(备注：以上内容来自七月老师的学习笔记，仅作为学习使用)