Python基础语法

基础语法

1、常量、表达式

print(1+2-4)
print(1+3*4)

形如： 1+2-3 这个就叫表达式 ，表达式的结果叫做叫做返回值

1 2 3 这样的数字称为字面值常量，+ - * 叫做运算符

注意在py中 2/3 = 0.66666 而不是c语言中的0

在C中 整数除整数 结果还是整数且会把小数直接舍去，在编程中一般不会有四舍五入这样的规则

浮点数：遵循IEEE754规则，这套规则在内存中存储时会存在微小的误差！！

2、认识变量

变量可以视为是一块用来存储数据的空间(想象成一个纸盒子)
变量是在内存上的

# 求方差
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
total = (67.5 - avg) ** 2 + (89.0 - avg)**2 + (12.9-avg)**2 + (32.2-avg) ** 2
result = total/3
print(result)

3、创建变量

硬性规则

1.变量名必须由数字，字母，下划线构成，不能包含特殊符号.
像a1是合法的变量名
像1a, a*a都是非法的变量名

2.数字不能开头

3.变量名不能和Python的"关键字"重复
在语法中有特定含义的单词
像if这种也是非法变量名~

4.Python中的变量名，是大小写敏感的，区分大小写.
num = 10
Num = 10

软性规则

1.给变量命名的时候,尽量使用描述性的单词来表示尽量通过名字来表现出变量的作用

count
personInfo
y,z,a1,a2不太合适的名字

2.当我们使用一个单词描述不清楚的时候可以使用多个单词来命名
不怕变量名字长，而怕变量的含义表达的不清楚，当包含多个单词的时候命名有多种规范
①驼峰命名除了第一个单词的首字母之外,后续每个单词的首字母都大写

personInfo
totalCount

②蛇形命名单词之间，使用下划线来进行分隔

person_info
total_count

在公司里开发商业程序，公司都会有明确的编程规范

4、使用变量

a=100
b=a
print(a)  # 读取

a=20
print(a)  # 第二次修改

out:
100
20    

5、变量的类型

对于不同种类的变量进行区分

1.整数int
Python中的变量的类型，不需要在定义变量的时候显式声明，而只是依靠初始化语句，根据初始化的值的类型来进行确定的
在 Python 中 int能够表示的数据范围，是"无穷”的，是可以根据要表示的数据的大小自动扩容，因此Python 这里就没有long这样的类型了，像byte, short这些类型在 Python中也不存在
Java int最大就能表示到 -21亿 ~ +21亿

2、浮点数(小数) float

Python中的float等同于C++/Java里的double就是双精度浮点数.

像C+＋和Java里面，float是四个字节的，也叫做“单精度浮点数”；double 是八个字节的，也叫做"双精度浮点数”

字节的含义：把一个二进制位称为一个bit，8个bit放在一起,就称为是一个字节

a=10
print(type(a))

b=1.1
print(type(b))

out:
<class 'int'>
<class 'float'>

3、字符串

---

有一段话: My name is “tangzhong” 把这段话作为字符串，如果字符串里面包含了双引号，表示字符串就可以用单引号引起来；如果字符串里面包含了单引号，表示字符串就可以使用双引号引起来。

如果同时有单引号，和双引号，咋办?
Python中还有一种字符串，使用三引号表示 ''' 或者"""

c='hello'
print(type(c))

d="world"
print(type(d))

f= " my name is 'shijunjie' "
print(f)
print(type(f))

out:
<class 'str'>
<class 'str'>
 my name is 'shijunjie' 
<class 'str'>

print(len(f))

a1="hello"
a2="world"
print((a1+" "+a2))

out:
23
hello world

在Python 中报错，有两种情况：
①语法错误，在程序运行之前，Python解释器，就能把错误识别出来。
②运行错误，在程序运行之前，识别不了的，必须要执行到对应的代码，才能发现问题。

4、布尔类型

真True
假False

注意都是大写

c1=True
c2=False
print(type(c1))
print(type(c2))

out:
<class 'bool'>
<class 'bool'>

5、其他类型

类型的意义？
类型带来的意义
1.不同的类型,占用的内存空间是不同的. 占几个字节
int默认是4个字节.动态扩容.
float固定8个字节.
bool一个字节就足够了
str变长的
2.不同的类型,对应能够进行的操作也是不同的
int / float,+ -*/ 则不能使用len函数
str +但是不能–不能*也不能/ 可以使用len函数

动态类型特性

变量类型在运行过程中，可以改变

a=10
print(type(a))

b='hello'
print(type(b))

out:
<class 'int'>
<class 'str'>

静态类型特性

程序运行过程中，类型始终不变，C++中

总结：

一个编程语言,是否是动态类型,只是取决于运行时，类型是否发生改变，不取决于变量定义的时候是否声明类型！

Python 作为一个动态类型的语言，在定义变量的时候，也是可以写类型的！

动态类型写法,比较灵活的提高了语言的表达能力，然鹅，在编程中， “灵活"这个词往往是"贬义”，更容易出错！相比之下，静态类型的语言还是更好一些的，尤其是在大型的程序中,多人协作开发。
因此很多公司，在创业之初，喜欢使用Python来开发，产品规模小，也就是一两个程序猿，很快的就能搞出来，但是当项目达到一定的规模之后，动态类型的劣势就逐渐体现了。很多公司就会针对之前Python 写的代码，使用其他语言进行重构。

6、注释

• 注释行

# 后面跟的就是注释

• 文档字符串三引号注释

"""
中间的就是注释
"""

批量注释：ctrl + /

7、输出到控制台

a =10
希望使用print打印出"a =10”这样的内容
我们希望把数字和字符串混在一起来打印

a = 10
print(f"a={a}")

print(f"a={a}") 这个语法就叫做格式化字符串 f-string，f=format，此时就可以使用{ }这样的语法,往字符串里嵌入变量或者表达式

像格式化打印字符串很多编程语言都进行了各自的探索

C中printf，使用%d，%s这样的占位符
C+＋采用了std:cout，使用<<
Java采用了字符串拼接，允许字符串和其他类型的值进行拼接

8、从控制台输入

# 通过控制台来获取一个数
num = input("请输入您要输入的数字：")
print(f"您输入的是{num}")

input 执行的时候，就会等待用户输入！这个等待可能是一个非常长的等待，完全就看用户啥时候去输入，如果用户始终不输入，就会一直在这里死等。
input返回的值，其实是一个str，如果只是单纯的拿到用户的输入，然后打印，此时就按照str打印即可，如果需要根据用户输入的内容进行算术计算,此时就需要先把读到的 str 转换为 int，可以使用int ( )

a = input("请输入第一个数字：")
b = input("请输入第一个数字：")

a=int(a)
b=int(b)
print(f"a+b={a+b}")

如果想把整数转化为字符串：

str()
float()

用户输入四个小数，求平均值？

a= input("请输入第1个数字：")
b= input("请输入第2个数字：")
c= input("请输入第3个数字：")
d= input("请输入第4个数字：")

a=float(a)
b=float(b)
c=float(c)
d=float(d)
avg= (a+b+c+d) /4
print(avg)

9、运算符

算数运算符

+ - * / % ** //

先算乘方,然后是乘除,最后算加减，如果运算过程中想修改默认的运算顺序，就需要加上( )

这种运行时出现的错误,也叫做"抛出异常"
如果程序运行过程中抛出异常,程序直接就终止了，异常后面的代码也就不会执行到了

有些编程语言中,除整数0也是会抛出异常，除浮点数0会得到无穷大，而Python都认为是除0异常。

除法的第二个问题：
截断的问题 整数/整数,如果除不尽，得到的就是小数,不会出现截断的情况
除了Python 之外，大部分的编程语言,都是整数除以整数,结果还是整数

地板除法 // 向下取整

# 除0 抛异常
# print(10/0)

# 得到小数
print(1/2)

# 开根号
print(2 ** 0.5)


# // 地板除法，向下取整
print(7//2)
print(-7//2)

output:
0.5
1.4142135623730951
3
-4

关系运算符

<= 是 "小于等于"
>= 是 "大于等于”
== 是 "等于"
!= 是 "不等于"

字符串是按照字典序来比较的；针对中文进行字符串大小比较,是没有意义的.至少按照默认的字典序来说,是没意义的!

字符串之间好像不能直接使用==或者!=来比较呀？
C strcmp，如果直接使用==本质上在比较两个字符串首元素地址.
Java equals方法，如果直接使用==本质上在比较这两个字符串是否是同一个对象
这是一个小众的行为
像Python直接使用==和!=来比较字符串内容相同是大部分编程语言遵守的规则

针对浮点数来说,使用==比较相等,存在一定的风险！
因为浮点数在内存中的存储和表示,是可能存在误差的!!这样的误差在进行算术运算的时候就可能被放大,从而导致== 的判定出现误判!

print(0.1)
print(0.2)
print(0.1+0.2)
print(0.3)

虽然这两个数字已经非常非常接近了,但是如果直接使用==进行比较,仍然会出现False的情况！

正确的比较浮点数相等：作差，看差值是否小于预期的误差范围！

a = 0.1+0.2
b = 0.3
print(-0.00001 < (a-b) < 0.00001)

Python中支持这种连续小于的写法。判定a - b既是小于0.000001又是大于-0.000001

逻辑运算符

and or not

a = 10
b = 20
c = 30
print(a < b and b < c)
print(a > b or b > c)
print(not a < b)

比如C+＋或者Java里：

• &&表示逻辑与 并且
• || 表示逻辑或 或者
• !表示逻辑非 逻辑取反.

逻辑运算符中的重要细节：短路求值
对于and操作来说,如果左侧表达式为False,那么整体的值一定是False,右侧表达式不必求值!
对于or操作来说,如果左侧表达式为True,那么整体的值一定是True,右侧表达式不必求值!

a = 10
b = 20
c = 30

print(a > b and 10 / 0 == 1)
print(a < b or 10 / 0 == 1)

右侧就不再求值了，所以一旦右侧求值了，是能够看到代码出现异常的!如果代码没有抛出异常,右侧没有求值!

赋值运算符

= 等号表示赋值

== 表示比较相等

链式赋值：

a=b=c=10

多元赋值：

a,b=10,20

# 使用多元赋值一步完成交换：
a = 10
b = 20
a, b = b, a
print(a, b)

复合运算符

Python中不支持+ +- -这样的自增自减操作的!!
++a之所以没有语法报错，是Python解释器把＋当成了正号

--a也是不会报错，把-当成了负号.负负得正,最终的值仍然不变
但是后置＋＋和后置- -都是语法上报错的!

使用a += 1已经很方便的完成了自增了
++操作其实挺讨厌，前置++和后置++的区别,对于初学者来说是非常不友好的!

10、其他

除了上述之外,Python中还有一些运算符,比如身份运算符(is, is not),成员运算符(in, not in),位运算符(&| ~ ^ << >>)等.