Python 基本语法

1. 编码

• 计算机所有的数据都是以0和1的组合来存储，将中文转换成01010101....，存储到硬盘。
• 在计算机中有很多编码，都有自己的规则，所有使用不同编码保存到硬盘中的0、1也不同。
• 以某种编码保存的文件，就要以这种编码去打开，否则就会出先乱码。
• 例如：以UTF-8编码保存的文件，就需要用UTF-8编码去打开，用GBK编码打开就会报编码错误
• 默认python解释器是以UTF-8打开文件，如果想要修改python解释器编码，如下
  • -*- coding:gbk -*- 告诉python解释器要以gbk形式打开代码文件。

# -*- coding:gbk -*-
print("gbk编码")

2.输入与输出

• input() 接收输入的值，需要有个变量name来接收输入的值。
• print() 将要打印的结果输出出来，

name = input("你的名字：") 
print("我的名字是" + name) # 输出：我的名字是张三

• 默认print在尾部自动换行符，想取消换行符可以加end，如：

print("aaaaaaaa",end="")     # 将末尾换行符取消
print("bbbbbbbb")

print("aaaaaaaa",end="，")   # 末尾以逗号结尾
print("bbbbbbbb",end="。")   # 末尾以句号结尾

3.数据类型

3.1 整型(int)

• 整型就是整数：和数字相关的就会用到整型。

print(1111)
print(1 + 1)

3.2 字符串(str)

• 字符串必须要用引号引起来，如：

# 单号字符串
print('字符串a')
print("字符串b")

# 多行字符串
print("""
姓名：a
年龄:5
""")
print('''
姓名：b
年龄:6
'''
)
# 字符串拼接
print("今天" + "天气" + "怎么样")

3.3 布尔类型(bool)

• 布尔类型只有两个值：True、False。
• 如果结果返回为真则返回True，如果结果返回为假则返回False，如：

print(1 > 2)  # 1 小于2 为假结果返回 False
print(False)

print("aa" == "aa") # aa 等于 aa 为真结果返回 True
print(True)

4.变量和常量

变量就是用来在程序运行期间存储各种需要临时保存可以不断改变的数据的标识符，一个变量应该有一个名字，并且在内存中占据一定的存储单元，在该存储单元中存放变量的值。

• 格式：变量名 = 值

name = "张三"
print("我的名字是" + name) # 输出：我的名字是张三

4.1 变量的定义规则

变量名要见名知意，不能瞎写，瞎写到后面自己都看不懂那个变量是干啥的，不要用拼音，更不要用中文当变量名。

• 变量名只能是 字母、数字或下划线的任意组合
• 变量名的第一个字符不能是数字
• 建议用下划线连接命名，命名小写，如:user_name = "张三"

以下关键字不能声明为变量名

['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 
     'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 
     'try', 'while', 'with', 'yield']

4.2 变量的内存指向

当我们写：name="张三"时，Python解释器干了两件事情：

1. 在内存中创建了一个'张三'的字符串，生成了一个内存地址。
2. 在内存中创建了一个名为name的变量，并把它指向'张三'。

这时候把变量name赋值给另一个变量new_name，这个操作实际上是把name变量"张三"的内存地址赋值给了new_name变量，与变量name并无任何关系；若name值变化，new_name的值依然无变化。
原因：字符串特性，一旦修改，重新创建
name的值发生变化，相当于重新开辟了一块内存空间；而new_name依然指向原有内存空间。

4.3 常量

量就是不能变的变量，比如常用的数学常数π就是一个常量。
在Python中，通常用全部大写的变量名表示常量：如 ABC

5.注释

# 单行注释


"""
多行注释
注释内容
"""

6.字符串格式化

方式一： %

# 字符串 %s
print("Hello,%s" % "world")

# 整数 %d
print("My age is %d" % 20)

# 浮点数 %f
print("My age is %f" % 20)　

name = input("what is your name?")
age = int(input("tell me you age:"))
job = input("job?")
salary = input("salary!")

info = '''
---- info of ------
name:%s
age:%d
job:%s
salary:%s
''' % (name,age,job,salary)
print(info)

方式二： .format

print("name:{}, age:{}".format("张三",14))
print("name:{0}, age:{1}".format("李四",16))
print("name:{_name}, age:{_age}".format(_name="王五",_age=18))

# 列表
print("name:{name[0]}, age:{age[2]}".format(name = ["马六","孙七"],age = [22,33,44]))

# 字典加元组
print("name:{name[sq]}, age:{age[2]}".format(name = {"ml":"马六","sq":"孙七"},age = (22,33,44)))

format 填充符号的使用

"""
^ 原字符串居中显示
> 原字符串居右显示
< 原字符串居左显示

{who:*^10}
* : 填充的符号
^ : 原字符串居中显示
10: 原字符串长度 + 填充符号的长度 = 10
"""
strvar = "{who:*^10}, {do:>>10}, {feel:!<10}".format(who="张三",do="李四",feel="王五")
print(strvar)
# 结果 
>>>：****张三****, >>>>>>>>李四, 王五!!!!!!!!

format 占位符

# (6)进制转换等特殊符号的使用( :d :f :s :, )

# :d 整型占位符 (强制要求类型是整型)
strvar = "刘一峰昨天晚上买了{:d}个花露水泡脚".format(9)
print(strvar)

# :3d 占3位,不够三位拿空格来补位(原字符串居右)
strvar = "刘一峰昨天晚上买了{:3d}个花露水泡脚".format(9)
print(strvar)
strvar = "刘一峰昨天晚上买了{:<3d}个花露水泡脚".format(9)
print(strvar)
strvar = "刘一峰昨天晚上买了{:^3d}个花露水泡脚".format(9)
print(strvar)

# :f 浮点型占位符 (强制要求类型是浮点型) 默认保留小数6位
strvar = "王雨涵毕业之后的薪资是{:f}".format(9.9)
print(strvar)

# :.2f 小数点后保留2位,存在四舍五入
strvar = "王雨涵毕业之后的薪资是{:.2f}".format(9.188888)
print(strvar)

# :s 字符串占位符
strvar = "{:s}".format("杨元涛真帅")
print(strvar)

# :, 金钱占位符
strvar = "{:,}".format(12345678)
print(strvar)

# 综合案例
strvar = "{:s}开工资{:.2f}元,买了{:d}个兰博基尼".format("孙坚",300000.12345,10)
print(strvar)

方式三：f"字符串{变量名}"

name = "Jack"
aa = 19
print(f"他的名字是{name}，他今年{aa} ")

# 进制转换
print(f'张三今年{22}岁')
print(f'张三今年{22:#b}岁') # :#b ，把22转换从2进制
print(f'张三今年{22:#o}岁') # :#b ，把22转换从8进制
print(f'张三今年{22:#x}岁') # :#b ，把22转换从16进制

7.运算符

7.1 算数运算符

例如:加减乘除

运算符	描述	实例
+	加-两个对象相加	a+b 输出结果 30
-	减-得到负数或是一个数减去另一个数	a-b输出结果-10
*	乘-两个数相乘或是返回一个被重复若干次的字符串	a*b 输出结果200
/	除-x除以y	b/a 输出结果2
%	取模-返回除法的余数	b % a 输出结果0
**	幂 -返回x的y次幂	a ** b为10的20次方,输出结果 100000000000000000000
//	取整除-返回商的整数部分	9//21输出结果4,9.0//2.0输出结果4.0

7.2 比较运算符

例如:大于、小于

运算符	描述	实例
==	等于-比较对象是否相等	(a == b)返回False。
!=	不等于-比较两个对象是否不相等	(a != b)返回 true.
<>	不等于-比较两个对象是否不相等	(a<>b)返回true。这个运算符类似 != 。
>	大于-返回x是否大于y	(a>b)返回False。
<	小于-返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写。	(a<b)返回true。
>=	大于等于-返回x是否大于等于y。	(a>=b)返回False。
<=	小于等于-返回x是否小于等于y。	(a <= b)返回true。

注意:python3中不支持<>

7.3 赋值运算

例如:变量赋值

运算符	描述	实例
=	简单的赋值运算符	c=a+b将a+b的运算结果赋值为c
+=	加法赋值运算符	c+=a 等效于c=c+a
-=	减法赋值运算符	C -= a 等效于c=c-a
*=	乘法赋值运算符	c *= a等效于c = c * a
/=	除法赋值运算符	c/=a 等效于c=c/a
%=	取模赋值运算符	c %=a 等效于c=c% a
**=	幂赋值运算符	c **= a 等效于 c=c ** a
//=	取整除赋值运算符	c//=a 等效于c=c//a

7.4 成员运算

例如：是否包含

运算符	描述	实例
in	如果在指定的序列中找到值返回True,否则返回False。	x在y序列中,如果x在y序列中返回True。
not in	如果在指定的序列中没有找到值返回True,否则返回False。	x不在y序列中,如果x不在y序列中返回True。

7.5 成逻辑运算

例如：且或非

运算符	描述	实例
and	布尔“与”-如果x为False,x and y返回False,否则它返回y的计算值。	(a and b)返回 true。
or	布尔“或”-如果x是True,它返回True,否则它返回y的计算值。	(a or b) 返回true。

优先级从高到底：算术运算符 > 比较 > in and or

and or用法：

v1 = name == "alex" and pwd == "123"
# v1 = True and False

if name == "alex" and pwd == "123":
pass


v2 = "wupeigi" and "alex"
# 第一步:将and前后的只转换为布尔值 True and True
#第二步:判断本次操作取决于谁?由于前面的是True,所以本次逻辑判断取决于后面的值。
#所以,后面的只等于多少最终结果就是多少。v2="alex"

v3 = "" and "alex"
# 第一步:将and前后的只转换为布尔值 False and True
#第二步:判断本次操作取决于谁?由于前面的是False,所以本次逻辑判断取决于前面的值。
#所以,前面的只等于多少最终结果就是多少。v2=""
v4 = 1 or 8
#第一步:将and前后的只转换为布尔值 True or True
#第二步:判断本次操作取决于谁?由于前面的是True,所以本次逻辑判断取决于前面的值。
# v4 = 1

v5 = 0 or 8
# 第一步:将and前后的只转换为布尔值 False or True
# 第二步:判断本次操作取决于谁?由于前面的是False,所以本次逻辑判断取决于后面的值。
# v5 = 8

练习题:

# or 看第一个值，第一个值为真则结果是第一个值，否则结果就是第二个值。
v1 = 1 or 2
v2 = -1 or 3
v3 = 0 or -1
v4 = 0 or 100
v5 = "" or 10
v6 = "jack" or ""
v7 = "" or 0
v8 = 0 or ""

print("v1值(1)：",v1,"  ","v2值(-1)：",v2,)
print("v3值(-1)：",v3,"  ","v4值(100)：",v4)
print("v5值(10)：",v5,"  ","v6值(jack)：",v6)
print("v7值(0)：",v7,"  ","v8值("")：",v8)
print(bool(-1))


# and 第一个值如果为真，结果就是第二个值，否则结果就是第一个值。
k1 = 4 and 8
k2 = 0 and 6
k3 = -1 and 88
k4 = "" and 7
k5 = "jack" and ""
k6 = "" and 0
k7 = 0 and "张三"

print(bool(""))
print("k1值(8)：",k1,"  ","k2值(0)：",k2,)
print("k3值(88)：",k3,"  ","k4值("")：",k4)
print("k5值("")：",k5,"  ","k6值("")：",k6)
print("k7值(0)：",k7)

如果多个and和or的情况，先计算and在计算or

v1 = 0 or 4 and 3 or 7 or 9 and 6
0 or 3 or 7 or 9 and 6
0 or 3 or 7 or 6
3 or 7 or 6
3 or 6
3

v2 = 8 or 3 and 4 or 2 and 0 or 9 and 7 # 结果：8
v3 = 0 or 2 and 3 and 4 or 6 and 0 or 3 # 结果：4

先计算not，在计算and，最后or

v2 = not 8 or 3 and 4 or 2 # 结果：4

7.6 比较运算

is 和 == 区别

• is ，判断内存地址是否相等
• == ，判断值是否相等

# 判断两个列表值是否相等
list1 = []
list2 = []
print(list1 == list2) # 结果：True
print(list1 is list2) # 结果：False

# 判断两个列表值是否相等
list1 = []
list2 = list1
print(list1 == list2) # 结果：True
print(list1 is list2) # 结果：True

# 判断两个列表值是否相等
list1 = None
list2 = None
print(list1 == list2) # 结果：True
print(list1 is list2) # 结果：True

7.7 位运算

• &，与运算(都为一)
  • &运算，看a和b对应的，位的进制是否都是1，都是1就写1，否则写0

# 0b 二进制前缀，用于明确标识一个数是二进制数

# (60：0011 1100 和 13：0000 1101)从右向左看，
# 第1位(a是0，b是1，a和b值都不为1，所以c第1位是0)
# 第2位(a是0，b是0，a和b值都不为1，所以c第2位是0)
# 第3位(a是1，b是1，a和b值都为1，所以c第3位是1)
# 第4位(a是1，b是1，a和b值都为1，所以c第4位是1)，以此类推
a = 60      # 60的二进制为：0011 1100
b = 13      # 13的二进制为：0000 1101
c = a & b   # 12的二进制为：0000 1100
print(bin(a),bin(b),bin(c))

• |,或(只要有一个为1，就是1)

# (60：0011 1100 和 13：0000 1101)从右向左看，
# 第1位(a是0，b是1，b为1，所以c第1位是1)
# 第2位(a是0，b是0，都不是1，所以c第2位是0)
# 第3位(a是1，b是1，都是1，所以c第3位是1)
# 第4位(a是1，b是1，都是1，所以c第4位是1)，以此类推
a = 60      # 60的二进制为：0011 1100
b = 13      # 13的二进制为：0000 1101
c = a | b   # 12的二进制为：0011 1101

• ^,异或(值不同为1)

# (60：0011 1100 和 13：0000 1101)从右向左看，
# 第1位(a是0，b是1，a和b值不同所以c第1位是1)
# 第2位(a是0，b是0，a和b值相同所以c第2位是0)
# 第3位(a是1，b是1，a和b值相同所以c第3位是0)
# 第4位(a是1，b是1，a和b值相同所以c第4位是0)，以此类推
a = 60      # 60的二进制为：0011 1100
b = 13      # 13的二进制为：0000 1101
c = a ^ b   # 12的二进制为：0011 0001

• ~,取反(0为1，1为0)

# 取反，把0变成1，把1变成0
# 取反结果为：原数+1再变相反数。
a = 60      # 60：0011 1100
c = ~a      #-60：1100 0011

• << ,左移动

# 向左移2位
a = 60      # 60：0011 1100
c = a << 2  #240：1111 0000
print(bin(a),bin(c))

• ,向右移动

# 向右移2位
a = 60      # 60：0011 1100
c = a >> 2  #240：1111 0000