在C/java中，整数除以整数结果还是整数，并不会将小数部分舍弃！

编程中一般没有四舍五入这样的规则，浮点数IEEE754标准，内存中表示浮点数时会存在微小的误差。

2^2用python表示是2**2

变量是一块存储数据的空间。

变量名最好别和关键字相同，会存在含义的覆盖，如果想用回原来关键字的含义，把新创建的删除就行。

创建变量和初始化以及他类型的确定，都是在首次使用=设置值

类型

type()内嵌函数查看变量类型，

int能表示的数据范围是无穷的，Python是可以根据要表示的数据的大小，自动扩容。就没有long，short，byte类型了。

int a=10是错的,非要指定类型的话是a:int=10

float，C++中是四字节，double是8字节。但是在Python中就是八字节双精度。

str：字符串类型，双引号和单引号都可以。特殊：st="My name is 'yuanwei'"，换过来也行，三引号也是可以的。st2='''Myname 'is' "yuanwei"'''随便换着来，三者没有上下关系。

len():求字符串的长度,只能用于字符串类型

字符串拼接:st=st1+st2,新的字符串存储.

语法错误,在成语运行之前解释器可以把错误找出来.

运行时错误必须要到执行到对应的代码才能发现问题

布尔类型:True&&False,必须大写.

不同的类型占用的内存空间是不同的,int是4字节动态扩容;float是8字节,bool一个字节

不同的类型能完成的操作也是不同的.

动态类型:变量类型会随着程序的运行发生改变

一个编程语言是否是动态类型,只是取决于程序运行时类型是否发生变化.所以Python是动态语言

比较灵活,但是更容易出错,各种类型都可以,但是只有在遇到具体操作符时才会出现类型的约束而报错

注释

但凡要更新代码,一定要更新注释.批量注释是ctrl+/

#这是一段注释
a=10 #这里也可以注释
'''
文档字符串,编译器不会去掉
'''

控制台

用户输入命令和机器进行交互,图形化界面应用更广泛.print()打印到控制台

a=10
print(f"a={a}")#格式化字符串,f-string,f是format
print(f"a={a+10}")

控制台输入input()

num=input("请输入一个数字")#返回值实际是字符串,存在类型强转float()int()str()
print(f"您输入的数字是{num}")

num1=int(input("请输入一个数字"))
num2=int(input("请输入一个数字"))
print(f"您的数字是{num1+num2}")

运算符

算术

**进行乘方运算,整数次方小数次方都可.2^0.5就是2**0.5

地板除法:7//2=3向下取证,-7//2=-4

关系

关系运算符不仅仅可以针对数字,还可以针对字符串,按照字典序比较就行.针对中文进行字符串大小比较时没有意义的,计算机里面表示中文使用多个字节表示一个较大的数字.

针对浮点数使用==比较相等存在风险,因为浮点数在内存中的表示是存在误差的.

正确写法:

print(-0.00001<(0.1+0.2-0.3)<0.00001)约定精确位数.在python中支持链式的比较.

逻辑

and or not print(not 10<20),print(10<20<30)

短路求值,对于and来说,如果左侧表达式为False,就没有必要看后面的条件了.print(10>20 and 10/0==1)

赋值

a=b=10 #链式赋值
a,b=10,20
#交换值,使用多元赋值
a,b=b,a
a+=1

python不支持+±-这样的自增自减操作,没有报错是因为将++当作是两个正号,值不改变.

总结

如果把布尔类型的值和正数进行算术运算,会把True当成1,False当成0.但是这样的操作是没有意义的.

python只有字符串类型,字符就是长度为1的字符串.""和’'没有任何区别

个正号,值不改变.a=true是错的,a=True是对的.

语句

判断语句

#pass空语句占位,避免编译错误
num=input("请输入一个数字")
if num !=1:
    #啥都不写
    pass
else:
    print(666)

while循环

for循环

for i in range(a,b,c):
    #[a,b)步长是c,负数的话就是反向打印

shift+F6 统一rename变量

range生成整数序列的可迭代对象

C语言中特殊操作goto,一般情况不建议使用

random.randint(1,6)左右都是闭区间生成一个随机整数.random是别人写好的模块,降低编程的门槛.自己也可以写,但是用别人的更快,不用自己测试bug啥的.

如果想引入其他模块使用import random,Pytharm 可以自动生成这条语句在头部.

函数

• #动态类型特性,只要保证类型能够实现对应的操作就行
  def add(x,y):
      return x+y
  
  print(add(10,20))
  print(add('hello','world'))
  print(add(10.5,10.8))
  print(add(str(10),'hello'))
  
  print(10,20,30)
  

• #一个函数尽量只完成一个任务(计算就是计算,打印就是打印),降低耦合度
  # 可以返回多个值
  def getPoint():
      x=10
      y=20
      return x,y
  a,b=getPoint()
  print(a,b)
  #如果只关注一个,就用_站位
  c,_=getPoint()
  print(c)
  

• def calSum(begin,end):
      thesum=0
      while begin<end+1:
          thesum+=begin
          begin+=1
      # print(thesum)
      return thesum   #可有可无
  

• 作用域的存在使得函数内外可以存在相同名字的变量.函数中优先读取函数内的局部变量,如果没有再访问全局的.

• 如果要在函数内修改全局变量global关键字.没有global,此时会把x=20当作是在函数内部创建的一个局部变量,而实际上是要修改全局变量,为了让函数里面知道是全局的,用global声明一下

  def test1():
      global x
      x=20
  test1()
  print(f"x真的={x}")
  

• 只有函数和类的代码块才涉及到作用域的概念,if else while for等语句代码块是不存在作用域的,变量在外部仍然可以访问.

• for i in range(1,11):
      print(f"内部的i:{i}")
  
  print(f"外部的i:{i}")
  

• Pycharm调试器:断点+debug+单步调试F7+函数调用栈

链式调用和嵌套调用

链式:一个函数的返回值当作另一个函数的参数

调试器左下角,是函数之间的调用栈,里面描述了当前代码的函数之间的调用关系,每一层栈帧选中之后都能看到他的变量.调用函数生成对应的栈帧,函数结束则对应的栈帧销毁.

局部变量在函数自己的栈帧上,虽然两个函数的局部变量名字相同但是不同的栈帧是不同的内存空间,也就是不同的变量.

递归

递归公式,递归结束条件

递归调用看起来是同一个函数,但是是两次调用,其实就是两个栈帧.

每一次递归都会主键接近结束条件.

求n!=n*(n-1)!

def factor(n):
    if n == 1:
        return 1
    return n* factor(n-1)
print(factor(5))

#形参默认值,带有默认值的要在参数列表的后面
def add(x,y,debug=False):
    if debug:
        print(f"x={x},y={y}")
    return x+y

result =add(10,20,True)
print(result)

关键字传参

def test(x,y):
    print(f"x={x},y={y}")

test(x=10,y=20)
test(y=20,x=10)
test(10,y=20)#关键字参数和位置参数混着用,位置参数放在前面

关键字参数配合着形参默认值使用,一般的函数形参都设定默认值,传参时指定关键字参数即可.