python基础

静态编译型语言：c c++ java

动态解释型：python javascript（脚本语言）

编译与解释的区别：

Demo.c ----》编译器----》Demo.exe                                     ====>

Demo.java ====》编译器=====》Demo。class===》JVM ====>Windows

 Demo.py =====>pvm解释·器                                               ====>

静态与动态的区别：

静态对于变量有明确的类型定义的   动态对变量没用明确类型定义

在 c c++ java中，基本数据类型变量（将常量数据储存在变量空间中），

而java中，引用数据类型变量（将对象在堆内存的地址给变量）

在c c++中，指针变量（储存的是变量的物理内存地址）

动态语言（所有的数据都是对象！所有的变量都是引用数据类型变量）

2.脚本与交互

交互模式：

打开cmd窗口，输入python指令，进入到python交互模式

弊端：代码不能永久保存，代码随着窗口关闭而消失

我们一般在进行简单的代码演示，测试时才会用到交互模式

脚本模式

：打开vscode，File，New Folder ，选择代码目录，New File 按键创建文件，输入名称和后缀名（.py）   一定养成随时按crtl +s的习惯 保存

打开CMD窗口，进入到代码目录路径

指令：python xxx.py运行 xxx.py文件

3.基本数据

   1.整数常量没有byte short long之分，全部默认int

print(0.12e10)将打印出1,200,000,000。
而0x12表示十六进制数，其中0x表示这是一个十六进制数的前缀，12是十六进制数的表示。将十六进制数12转换为十进制数，结果为18。

因此，print(0x12)将打印出十进制数18。
     2.小数常量

没有byte short long之分，全部算int

在Python中，print(0.12e10)表示打印出科学计数法表示的数字。在这种表示法中，数字被分为两部分：基数和指数。在这个例子中，0.12是基数，e是表示乘以10的幂，10是指数。因此，0.12e10实际上等于0.12乘以10的10次方，即1,200,000,000。

     3.字符串常量

表示一段文本信息，程序会将文本信息原封不动的处理

python没有字符的数据，全部当顺风车处理，双引号和单引号都可以表示字符串

print（“张老师说：‘好好学习’”）

张老师说：‘好好学习’

    布尔常量

只有Ture，False

    复数常量

>>> 1+2i

（1+2i）

>>>complex（1,2）

（1 +2j）

>>>（1 +2i）*（1 -2i）

（5 +0i）

  表示符

就是我们自定义的名称（变量 函数 类）

规则：
有数字，字母，下划线，美元符组成

数字不能开头

是一个连续的词，中间不能有空格分开

被赋予特殊含义的单词不能随意使用

   小驼峰：变量 函数 多个单词出现时 第一个单词首字母小写 之后单词首字母都大写 myName

  大驼峰：类 所有单词首字母大写 MyName

  下划线分割：单词之间用下划线分割 不大写 my_name

  起的任何名字必须有含义，就算英文单词记得不多，也可以允许用拼音

数据转换

    >>> int("AD", 16) # 将数字字符串进行十六进制解析，结果都是十进制

   173

   >>> int("91A", 12)

   1318

    >>> 10 * 12 ** 0 + 1 * 12 ** 1 + 9 * 12 ** 2

float():将其他数据转为小数

str（）：将其他数据转为字符串

blool：（）将其他数据转为布尔类型

进制转换 >>> bin(123) # 转二进制字符串 '0b1111011'

>>> oct(123) # 转八进制字符串 '0o173'

>>> hex(123) # 转十六进制字符串 '0x7b'

字符与ASCII码转换

a~z A~Z 0~9 他们在ASCII中的编号都是连续的

ord()：获取字符对应的ASCII码编号

>>> ord('a') 97 >>> ord('A') 65

>>> ord('0') 48 chr()：根据给定的ASCII码编号获取对应的字符

>>> chr(98) 'b'

>>> chr(57) '9'

A = 10 B = 11 ...... F = 15

13 - D

chr(ord('A') + 13 - 10)

常见的数学计算

>>> abs(3.14) # 取绝对值

3.14

>>> abs(-3.14)

3.14

>>> pow(2, 4) # 求a 的 b 次幂 16

>>> pow(2.0, 4)

16.0

>>> pow(16, 0.5)

4.0

>>> max(1, 2, 3, 4) # 求最值问题

4

>>> min(1,2,3,4)

1

>>> round(3.14) #四舍五入

3

>>> round(3.51)

4

输入与输出

eval（）函数用于执行存储在字符串中的 Python 表达式。它将输入的字符串作为 Python 表达式进行求值，并返回表达式的结果。

# 处理一行内多个数据的输入

# eval处理的数据必须要有逗号分隔

# eval自动处理字符串解析

# eval既可以处理单值 也可以处理多值

print("Hello World")

print(1 + 2 + 3)

print(1, 2, 3, "Hello World!")

# 多数据输出 用空格分隔

print(1, 2, 3, sep = "#")

# sep默认空格

 这行代码是在Python中用来打印数字1、2和3，其中使用了`sep`参数来指定打印时数字之间的分隔符。在这里，分隔符被设置为"#"，所以打印出来的结果将是"1#2#3"。
 

print(1, 2, 3, end = "!!!") # end输出的解围默认"\n"

这行代码是在Python中用来打印数字1、2和3，其中使用了`end`参数来指定打印结束时的字符。在这里，结束字符被设置为"!!!"，所以打印出来的结果将是"1 2 3!!!"。 默认情况下，`print`函数在打印完所有内容后会自动添加换行符"\n"，但通过设置`end`参数，可以改变这个行为。
 

# print(*args, sep=' ', end='\n', file=None, flush=False)

print(1, 2, 3, end = "!!!")

print("Hello World", end = "!!!")

print("Hello World", end = "!!!")

print() # 单独一个print换行的意思 其实打印的是空串

# 格式化输出 name = "旺财"

age = 18 height = 1.23

print("它叫", name, "，今年", age, "岁", sep = "")

# %s 对应字符串 %d 对应整数 %f 对应小数

print("它叫%s，今年%d岁，身高%.2f米" % (name, age, height)

算数运算符

>>> 1 + 2

3 

>>> “123  +“456”

‘123456’

减法：数值相减

乘法：数值相乘法，序列增加

>>> 3 * 6

18

>>> "我爱你" * 3 '

我爱你我爱你我爱你

除法：小数除 /  整数除 //

整数除 只要两边都是整数 结果一律为整数 但凡有一个小数 结果就是小数（只有整数位，小数位都为0）

>>> 10 / 2

5.0

>>> 10 // 2

5

>>> 10 / 3

3.3333333333333335

>>> 10 // 3

3

>>> 10.0 // 3

3.0

>>> 10.5 // 3

3.0

幂运算

>>> 2 ** 3

8

>>> 16 ** 0.5

4.0

取余：

10/3 =3 -1

>>> 10 % 3 1

取余经常用于哪些场景，带有数据重复或循环的情况

22日对应周五，22 % 7 = 1 余数为1 则对应周五 0 对应周四....

30 % 7 = 2 对应周六

布尔判断运算符

运算结果一律为布尔值 大于 小于 大于等于 小于等于 不等于 等于

> < >= <= != ==

Python允许连续比较

>> 1 < 2 < 3

True

>>> 1 < 2 and 2 < 3

True

在Python当中 == 到底比得是啥？

答：比的是具体对象的值

>>> a = 1

>>> b = 1

>>> id(a) # id 取变量中存储的数据对象在内存中的地址

140715464473016

>>> id(b)

140715464473016

>>> a = 1000

>>> b = 1000

>>> id(a)

3267440575376

>>> id(b)

3267440589968

可以发现a和b在为1000时 对象地址不一样？ 因为在Python当中 只有-5~256 Python会自动创建这些数据对象，提供给调用者使用 也就意味着如果创建该范围之外的数据对象的话，Python则重新创建新的对象出来 a = 1000, b = 1000 其实是两个1000数据的对象 a == b 比的是对象的内容 但是a和b存的地址不一样 a = 1, b = 1, 其实只有一个 1 数据的对象

a == b 比的是对象的内容 但是a和b存的地址一样

增强型赋值运算符

+= -= *= /= //= **= %=

a += 2

a = a + 2

b **= 2

b = b ** 2

额外多说一句：在Python中 是不存在 ++ --这种自增运算符的

逻辑运算符

与 或 非 = and or not （&& || !）

与：全真则真 有假则假

或：有真则真 全假则假

非：取反

>>> 1 < 2 and 2 < 3 True

>>> 1 < 2 or 2 > 3 True

>>> not 1 < 2 False

& 与 &&的区别

int x = 0;

int y = 0;

System.out.println(x++ < 0 & y ++ < 0); //无论左边是否为假 右边都要计算

System.out.println(x); //1

System.out.println(y); //1

int x = 0;

int y = 0;

System.out.println(x++ < 0 && y ++ < 0); //如果左边是假 右边不计算

System.out.println(x); //1

System.out.println(y); //0

&& 就是为了避免一些没有必要的计算 提高效率

位运算符

&按位与

>>> 13 & 7

5

1101

0111

0101 = 5

|按位或

>>> 13 | 7

15

1101

0111

1111 = 15

<< 左移

>> 2 << 3

16

0010

0010000

10000 = 16

2 * 2 ^ 3

~取反 符号取反再减1

>>> ~15

-16

01111 = 15

10000 = -16

^ 异或：相等为假 不同为真

>>> 13 ^ 7

10

1101

0111

1010 = 10

关于变量交换值

a = 1 b = 3

temp = a

a = b

b = temp

a, b = b, a # Python自带的交换特点

只针对整数

a = 10

b = 100

a = a + b # 110

b = a - b # 10

a = a - b # 100

只针对整数

a = a ^ b

b = a ^ b

a = a ^ b

成员运算符

in 和 not in 判断一个元素是否在另一个序列中

>>> "abc" in "sakjdgjhsgadugashjdvasvdjgsa"

False

>>> "abc" in "sakjdgabca"

True

>>> 1 in [2,3,4]

False

从属/身份运算符

is 和 not is 判断两个变量指向的对象是否是同一个对象（比地址）

>>> a = 1

>>> b = 1

>>> a == b

True

>>> a is b

True

>>> a == 1000

False

>>> a = 1000

>>> b = 1000

>>> a == b

True >

>> a is b

False

>>> a = "abc" # 字符串

>>> b = "abc" # 之前已经创建了"abc" 这里直接复用 而不是重新创建 跟整数是有区别的

>>> a == b

True

>>> a is b

True

>>> id(a)

140715463387184

>>> id(b)

140715463387184