初始python-1

python的优缺点：

优点：

• 语法简介容易上手
• 功能强大，用途广泛
• 生态丰富，具有海量的成熟第三方库
• 因为python是在c语言基础之上研发的，所以他能很方便的调用C/C++的代码进行高性能/系统级操作（因为python程序性能要弱上一点，由这一点， 我们可以用C/C++来帮助python实现一些高性能阶段）

缺点：

• 执行效率比较弱（相对于C/C++来说）（像一些典型的程序，满几十倍都是差不多的）
• 对于多个核心并发程序支持偏弱（并发执行：像我们现在的很多电脑的cpu都是多核的，也就是说我们cpu可以同时跑很多的程序，这就叫并发执行）（但是有其他手段可以帮助我们绕过这个阶段，但是不如python原生系统好）
• 动态类型系统对于大小相符不太友好（动态类型就是说在程序运行的时候，这个变量的类型是可以改变的）

 基础语法

在python中不像C语言一样用  “ ；” 来区分语句，他可以用换行来区分每一条语句，但是如果一行里面有多条语句的时候就要用  “ ；” 来区分：

a = 10
print(a)

a = 10 ; print(a)

 常量与表达式

 我们可以把python当做是一个计算器

print(1 + 2 - 3)    #输出结果是0
print(1 + 2 * 3)    #输出结果是7
print(1 + 2 / 3)    #输出结果是1.666666666667

print函数是python里内置的一个函数，我们可以把这样的 "  + - * / ()  " 等来进行算数运算，他满足先算乘除后算加减的规则。而 "1 + 2 - 3" 这样的叫做算式，在编程语言中叫做表达式，这个算式的结果就是这个算式的返回值。形如 "  + - * / ()  " 的我们称作 运算符 或者 操作符，而上面的 ”1“ ”2“ ”3“ 这样的我们称为字面值常量。需要注意的是我们在C中计算 "2/3" 的时候结果是0 ，但是在python中是符合我们日常使用直觉的小数。

例：

给定四个分数，67.5 ， 89.0 , 12.9 , 32.2 ，编写代码，求着四个分数的平均数。

print((67.5+89.0+12.9+32.2) / 4)

 变量和类型

例：

给定四个分数，67.5 ， 89.0 , 12.9 , 32.2 ，编写代码，求着四个分数的方差。

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

 像avg 和 total 这两个就是变量，而 “ ** ” 在python中表示乘方运算，“ **2 ”即为求平方。

变量可以视为一块能够容纳数据的空间，变量可以保存我们的中间值。

变量的语法

 变量命名的规则，

• 变量名必须由数组，字母，下划线构成，不能有特殊符号，像1a，a*a等等这些都是不合法的
• 数字不能开头 ，a1这样命名是合法的，1a不合法。
• 变量名不能和python的关键字重合
• python中的变量名是大小写敏感的，区分大小写

 变量的类型

 打印变量a的类型

a = 10
print(type(a))   #输出int

在python中变量类型不需要像c语言一样在定义变量的时候进行声明，而只是依靠初始化语句，根据初始化的值的类型来进行确定这个变量的类型。

int类型

在java里面的int类型表示的范围是：-21亿 -- 21亿，但是在python中int的表示范围是“无限”的，因为python的int类型是可以根据我们要表示的数据大小进行自动扩容，假如我们给了他一个很大的数据，那么python会帮我们分配更多的空间，保证能储存这个数字。因此，python里没有像long int这样的长类型了，还有byte，short这样的类型也是不存在的。

float类型

在c/java这些语言中的float类型都是4个字节的，所以表示位数也很有限，所以有了double这样的双精度浮点数这样的类型，但是在python中的float类型就是双精度浮点数，相对于java里面的double类型。

字符串（str类型）

python里面的字符串只需要把需要的字符用 双引号--” 或者是 单引号--‘括起来，就是字符串了。

c = 'hello'
print(type(c))    #输出 str

d = "hello"
print(type(d))    #输出 str

那为什么双引号和单引号都可以呢？我们举一个例子

 比如这段代码，我想把我的名字用双引号括起来，但是现在我的编译器报错了，报错的理由其实很简单，就是编译器把左边两个双引号中间的内容和右边两个双引号中间的内容看做是两个字符串了，中间的“zhangsan”这个字符串编译器就不认识。

如果字符串里包含了双引号表示的字符串，我们可以用单引号引起来；如果字符串里包含了单引号表示的字符串，就可以使用双引号括起来；如果同时有单引号和双引号的话，还可以用三引号来表示（'''  ''')或者（"""  """) 

 这两种都是正确的。

打印字符串长度

c = 'hello'
print(len(c))   #输出5  5就是这个字符的长度

字符串拼接

a1 = 'hello'
a2 = 'world'
print(a1 + a2)   #输出helloworld

这样子拼接字符串不影响a1和a2的值，需要注意的是这样子拼接只支持字符串和字符串的拼接，其他类型是不能和字符串拼接的。

a = 'hello'
b = 10
print(a + b)   #会报错

bool类型

bool 类型只有两个值（True（真）和False（假））True对于值1，False对应值2（注意：在python中的True和False的首字母都是大写的，而在java和c++里面的都是小写的）

print(true+1)  #2
print(false+1) #1

f1 = True
f2 = False
print(f1,type(f1))   #True
print(f2,typq(f2))   #False
#bool值可以转换成整数计算
print(f1+1)          #2
print(f2+1)          #1

动态类型：指的是程序运行过程中，变量的类型可能会发生改变。

a = 10;
print(type(a))  #<class 'int'>

a = 'hello'
print(type(a))  #<class 'str'>

a = True
print(type(a))  #<class 'bool'>

我们发现在给a赋上不同类型的值的时候，a的类型随着程序发生了改变。

静态类型：程序运行过程中变量的类型始终不发生改变，在java，c++中的变量的类型都是不变的。

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

而python作为一个动态类型的语言，在顶定义变量的时候也是可以写类型的声明的。

a:int = 10

a:str = 'hello'

a:bool = True

 虽然动态类型的写法比较灵活，提高了语言的表达能力，但是在编程中，‘灵活’这个词往往是‘贬义’的，更容易出错。相比之下，静态类型的语言还是更好一些，这一点尤其是在一些大型的，多人协作开发的程序之中。例如我们在一个大型的项目之中创建了一个动态变量，那么这个变量我们究竟能放什么样子的类型，当我们不知道的时候我们就需要去问定义这个变量的人，甚至要写一个文档去专门说明这个变量的取值，这样就不方便我们去开发我们的项目；相反对于静态变量，如果我们赋值错误了编译器就会直接报错，这样就少了很多的沟通成本。

注释

 注释是一种特殊的代码，他不会影响程序的运行，但是能够期待解释说明的作用，能够帮助程序员理解程序代码的执行逻辑。

行注释：

#这就是python中写注释的方式
#实现a+b，并打印结果
a = 10
b = 20
print(a + b)  #30

文档字符串：
使用三引号引起来的称为“文档字符串”，也可以视为是一种注释。（'''   '''  或者是  """   """ )

"""
这是文档字符串
这是文档字符串
"""

'''
这是文档字符串
这是文档字符串
'''

输入输出

 和用户交互

 程序需要和用户进行交互：

• 用户把学习传递给程序的过程，称为：“输入”
• 程序把结果展示给用户的过程，称为：“输出”

 输出

我们在c中可以用一下的方式输出“a = 10"

int a = 10;
printf("a = %d",a);  
//输出结果是   a = 10   

在python中实现：

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

 这个语法叫做“格式化字符串”   (f-string)，这里的 “ f “ 表示的是format也就是格式，当我们在这个”a = "这个字符串的前面加上“ f “ 之后就可以在这个字符串里面用{ }这样的语法，把需要打印的变量或者是表达式给嵌入到这个字符串里面。如下例子：

a = 10
print(f"a = {a + 10}")
#输出  a = 20

输入

我们在python中通过  input  来输入一个数据，input执行的时候，就会等待用户输入。

num = input('请输入一个整数：')
print(f'您输入的数字是{num}')

#输出结果是：
#请输入一个整数：10
#您输入的数字是10

 input的返回值是str字符串类型：

如果只是单纯的拿到用户的输入，然后打印的话，此时就按照str打印即可

如果需要根据用户输入的内容进行算术运算，此时就需要先把读到的str->int ，可以用int()来实现类型转换。

类型转换之前：

a = input("请输入第一个整数: ")  #假设输出10
b = input("请输入第二个整数: ")  #假设输出20

print(f'a + b = {a + b}')    #输出的是:    a + b = 1020 
                             #我们发现在没有转换类型的情况下，输出的结果只是字符串拼接的结果

 类型转换之后：

a = input("请输入第一个整数: ")  #假设输出10
b = input("请输入第二个整数: ")  #假设输出20

a = int (a)   #原本a的类型是str，现在把a的类型转换成int
b = int (b)   #转换int

print(f'a + b = {a + b}')    #此时的输出结果是：   a + b = 30

我们上是把str类型转换成int类型，那么类似的，我们想转换成str类型就 str（变量）就行了。

例子：输入四个小数，求着四个小数的平均值

a = input ("请输入第一个数字：")
b = input ("请输入第二个数字：")
c = input ("请输入第三个数字：")
d = input ("请输入第四个数字：")

a = float(a)
b = float(b)
c = float(c)
d = float(d)

avg = (a + b + c + d) / 4
print(f"平均值是 {avg}")

算数运算符

 + - * 、 %   **  //   （先算乘方，然后是乘除，最后是加减，除非用（）来修改运算顺序）

“ ** ” 乘方运算 

print(4 ** 2)    # 16
print(4 ** 0.5)  # 2.0

 “ // ” 地板除法（取整除法）

 他会针对计算的结果进行“向下取整”：

print(7 // 2)    # 不再是3.5，其结果是3

需要注意的是，这个取整除法的正负数的取整方式不一样：

print(-7 // 2)      #输出结果不是-3 ， 而是-4

他是向下取整，也就是说正数的时候，小数部分直接舍去不要，只保留整数部分；而负数的时候我们要理解他的向下取整，-7 / 2 的结果应该是-3.5，那么在-4和-3两者比，肯定是-4较小，所以再取整的时候取得是-4。

关系运算符

 <  <=  >  >=  ==  != 

关系运算符对应的表达式，值是bool类型，符合要求是True，不符合要求是false，而且在python中，这个比较的数据不仅仅可以是数字，还可以是字符串。

a = 'hello'
b = 'world'

print(a < b)     #输出 True
print(a > b)     #False
print(a <= b)    #True
print(a >= b)    #False
print(a == b)    #False
print(a != b)    #True

字符串的比较规则：

在英文词典上，单词是按照一定的顺序来排列的，先看首字母在字母表的顺序，谁小谁就排在前面，然后再比较第二个字母，一直如此直到把两个字符串比较完为止。注意：针对中文字符串进行大小比较至少按照默认的字典序来说是没有意义，在计算机里表示中文，其实使用多个字节构成的一个比较大的数字来进行比较。

在C中，用strcmp函数来比较字符串大小，如果使用 == 本质上比较的是两个字符串首元素的地址

在java中，用equals方法来实现，如果直接使用 == 本质上是在比较这两字符串是否是用一个对象

针对浮点数：

如果是针对浮点数的比较，使用 == 比较相等，存在一定的风险，因为浮点数在内存中的存储和表示，是看存在误差的，这样的误差在进行算数运算的时候就可能会被放大，从而导致 == 的判断出现误判，例如：

print(0.1 + 0.2 == 0.3)   #输出结果不是True，而是False

我们来看下面的例子：

print(0.1)            #0.1
print(0.2)            #0.2
print(0.1 + 0.2)      #0.30000000000000004
print(0.3)            #0.3

我们发现0.1 + 0.2 的结果和0.3非常的接近，但是并不相等。

正确的比较浮点数相等：

作差，看差值是否小于预期的误差范围！

a = 0.1 + 0.2
b = 0.3

#看a-b的差是否是一个非常小的数字，是否在误差范围之内
print(-0.000001 < (a-b) < 0.000001)

 我们称满足上面的条件就表示相减的结果在误差范围之内，我们认为这个是相等的。

我们这里使用了一个连续比较的写法，这个写法在java 和 c中都是不支持的，但是在python中支持这种连续小于的写法。

逻辑运算符

and  并且  （两侧的操作数均为 True ，表达式的值为True；否则为False）

or  或者     （两侧的操作室只要有一个为Ture，表达式的值为True）

not  逻辑取反 （只有一个操作数，操作数为True，则返回False，操作数为False，则返回Ture）

 例：

a = 10
b = 20 
c = 30

print(a < b and b < c)  #True
print(a < b and b > c)  #False

print(a > b or b < c)   #True
print(a < b or b > c)   #True
print(a > b or b > c)   #False

print(not a < b)        #False
print(not a > b)        #True

注：逻辑运算符中的重要细节：短路求值

对于and来说，如果左侧表达式为False，那么整体表达式的值就是False，那么右侧的表达式不必求值。

对于 or 操作来说，如果左侧表达式为True，那么整体的表达式一定是True，右侧表达式不必求值

赋值运算符

“ = ”     " == "   " += "   " -= "   "  

“ = ”表示是吧右侧的值填充到左边的空间中， " == " 表示比较左右两边相等。

a = b = 20    #先把20 赋值给b，再把b的值赋值给a

a , b = 10 , 20   #表示把 10 赋值给 a ，再把 20 赋值给 b （多元赋值）

上述中的多元变换可以帮我们完成两个变量的交换：

a = 10
b = 20

#一般交换变量的办法是创建一个中间变量来进行两个数据的交换
tmp = a 
a = b
n = tmp
print(a,b)  #输出为20  10


#利用多元变换实现两个变量的交换
a , b = b , a   
print(a , b)  #输出为20  10

再c中我们有 ” ++a “ 和 ” a++ “ 这种操作，但是在python中是不行的：

a = 0
++a
print(a)

运行结果：

 我们发现，编译器没有报错，但是这个结果不是1，是0，说明这个++a这个算式没有效果，在python中不支持 ++ -- 自减自增操作的，我们的 ++a 之所以没有报错是因为python的编译器因为这个 ++ 是a前面的正号，而当我们输入 a++ 这样的运算的时候，python就会报错了。

我们知道前置++，和后置++是不同的意思，前者的表达式返回的是自增之后的值，后者返回表达式自增之前的值。其实这样是不太方便的，所以在之后的go语言（golang）中废除了前置++，只保留了后置++，而且这个后置++不能取表达式的返回值。

成员运算符

in	如果在指定序列中找到值，返回True，否则返回False
not in	如果在指定序列中没有找到值。返回True，否则返回False

 身份运算符

is	is是判断两个标识符是不是引用自同一个对象，如果是，返回True，否则返回False
is not	is not 是判断两个标识符是否引用自不同对象，如果是不同对象，返回True，否则返回False

---

打印python中的关键字

import keyword
print(keyword.kwlist)

输出结果：

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

缩进：

python当中没有像c语言中的用{}和；来判断一条语句是否结束，它是利用缩进和换行的来判断语句的

if 2>1:      #print函数在if判断函数语句里
  print('yes')

\\\\\\\\\\\\\\\\\\\\\\\\\\\\

if 2>1:     #print函数没有在if函数语句里
print('yes')