1.基本数据
Python
能够操作的数据都有哪些
常量 ：不能够改变的量-字面量
1.整数常量
>>>
print
(
10
)
#
十进制
10
>>>
print
(
0b1001
)
#
二进制
binary
9
>>>
print
(
0o12
)
#
八进制
Oct...
10
>>>
print
(
0x12
)
#
十六进制
Hex...
18
进制转换：
十进制转七进制：
十进制123转七进制：
123
%
7
=
4
17
%
7
=
3
2
%
7
=
2
234
七进制
234七进制转十进制：
4
*
7
^
0
+
3
*
7
^
1
+
2
*
7
^
2
=
4
+
21
+
98
=
123
注意：没有
byte short long
之分 一律默认
int
2.小数常量
>>> print(1.34)
1.34
>>> print(0.12e10) #0.12*10^10
1200000000.0
注意：没有
float
与
double
之分 默认
float
3.字符串常量
字符串表示一段文本信息，程序会将文本信息原封不动的处理
>>> print("1+2+3")
1+2+3
>>> print('1+2+3')
1+2+3
Python
没有字符的数据，一律当成字符串处理，双引号和单引号都可以表示字符串
>>> print("
张老师说
:"
好好学习
"")
File "<stdin>", line 1
print("
张老师说
:"
好好学习
"")
^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?
>>> print("
张老师说
:'
好好学习
'")
张老师说
:'
好好学习
'
不能用相同的引号包裹相同的引号，否则会报错，Python解释器会遇到语法错误
可以用不同的引号包裹不同的引号，或者使用转义字符来消除语法错误
4.
布尔值常量
只有两个值
True
，
False
，
T
和
F
是大写的
>>>
print
(
True
+
1
)
2
>>>
print
(
False
+
1
)
1
True
如果参与运算默认为
1 False
默认为
0
，这种有意义吗？
在某些编程语言中，布尔类型的True和False可以隐式地转换为整数类型进行运算。其中，True通常被解释为1，而False通常被解释为0。这种隐式的转换在某些情况下是有意义的，但需要小心使用。
以下是一些可能有意义的应用场景：
-
计数和累加：在对布尔值进行计数或累加时，将True视为1，False视为0，可以方便地统计满足某个条件的次数或进行累加操作。
-
条件求和：可以使用条件表达式和布尔运算符，将布尔值隐式转换为1或0，从而在求和操作中根据条件进行累加。
-
位运算：在某些编程语言中，布尔值可以参与位运算。True可以被解释为1，False可以被解释为0，这样可以进行位与、位或等操作。
尽管这种隐式转换可以在一些情况下简化代码，但也容易引起混淆和错误。因此，在编写代码时应该注意这种转换，并确保使用时符合预期。
需要注意的是，并非所有编程语言都采用这种隐式转换规则，具体规定可能因语言而异。因此，在具体使用时，还需要查看相关语言的规范或文档以了解具体行为。
5.复数常量
>>> 1+2j
(1+2j)
>>> complex(1,2)
(1+2j)
>>> (1+2j)*(1-2j)
(5+0j)
注：J ** 2 = -1
标识符：就是我们程序员自定义的一些名称（变量 函数 类）
规则：
由字母、数字、下划线、美元符组成
数字不能开头
是一个连续的词，中间不能有空格分开
规范：
小驼峰：变量 函数 多个单词出现时 第一个单词首字母小写 之后单词首字母都大写
myName
大驼峰：类
所有单词首字母大写
MyName
下划线分割：单词之间用下划线分割 不大写
my_name
起的任何名字必须有含义，就算英文单词记得不多，也可以允许用拼音
关键字 ：就是一些单词，被Python赋予了特殊的含义，不能随便使用
>>> 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自带的一些具有特殊功能的函数
内置函数名称不要修改：
1.功能覆盖：内置函数是编程语言提供的核心功能，用于执行常见的操作。如果您修改了内置函数的名称，可能会导致原本的功能被覆盖，无法正常调用内置函数完成预期的操作。
2.代码可读性：内置函数的名称是广泛被认知的，其他开发者在阅读您的代码时会期望看到标准的内置函数名称。如果您修改了内置函数的名称，可能会增加其他开发者理解代码的难度。
>>> print(123)
123
>>> print = 3
>>> print + 4
7
>>> print(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> print(3)
3
>>> show = print #
把
print
指向的那个函数给了
show
>>> print = 3 #
把
3
对象的地址给了
print
>>> print + 4
7
>>> show(7)
7
所以，我们在使用内置函数的时候，一定要注意名称不能够被更改
>>>
max
(
432
,
5443
,
1
,
2
,
5
,
6
,
78
,
4
,
5
,
435
)
5443
>>>
max
=
10
>>>
max
(
1
,
2
,
3
)
Traceback
(
most recent call last
):
File
"<stdin>"
,
line
1
,
in
<
module
>
TypeError
:
'int'
object
is not
callable
注释：
单行注释
#
后面就是注释的内容 直到换行为止
多行注释
"""
中间多行注释
"""
变量：
在
Python
当中 变量其实就是一个万能箱子 他可以存储任何数据
本质：变量它只存储数据在内存中的地址（引用类型变量）
扩展：（数据类型 变量名
=
数据
# C Java）
变量 =
数据
单独定义一个变量时
>>> a = 1
>>> b = 2
同时定义多个变量，给定多个数据
>>> a, b, c = 1, 2, 3
>>> a
1
>>> b
2
>>> c
3
多个变量的值是一样的
>>> a = b = c = 1
>>> a
1
>>> b
1
>>> c
1
2.数据转换
int() 将其他有效的数据转为整数
1
.取整
2.
从字符串中解析整数
>>> int(3.14) #
将小数进行取整操作
3
>>> int("123") #
将数字字符串进行解析（默认十进制），解析出一个整数
123
>>> int("123abc")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '123abc'
>>> int("AD", 16) #
将数字字符串进行十六进制解析，结果都是十进制
173
# 10*16^1 + 13*16^0 = 173
>>> int("91A", 12)
1318
>>> 10 * 12 ** 0 + 1 * 12 ** 1 + 9 * 12 ** 2
1318
>>> int("A1F", 13)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 13: 'A1F'
>>> int("91a", 100)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: int() base must be >= 2 and <= 36, or 0
base
进制基数
= [2, 36]
>>> int("98*!",12) #
出现特殊符号
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 12: '98*!'
>>> int("10010101") #
注意坑 二进制串特不一定是二进制数字
10010101
>>> int("10010101", 2)
149
float()：将其他的数据转为小数
>>> float(3)
3.0
>>> float(3.14)
3.14
>>> float("3.14")
3.14
>>> float("3.14", 10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: float expected at most 1 argument, got 2
str()：将其他数据转字符串
>>> str(123)
'123'
>>> str(3.14)
'3.14'
>>> str(print)
'<built-in function print>'
bool()：将其他数据转布尔类型
# 对于数值类型的话 非0全是True 0就是False
>>> bool(1)
True
>>> bool(-1)
True
>>> bool(0)
False
>>> bool(3.14)
True
>>> bool(-3.14)
True
>>> bool(0.0)
False
# 对字符串 空串为False 非空为True
>>> bool("abc")
True
>>> bool("") #
空串
False
进制转换
>>> bin(123) #
转二进制字符串
'0b1111011'
>>> oct(123) #
转八进制字符串
'0o173'
>>> hex(123) #
转十六进制字符串
'0x7b'
>>> bin("123")
# 参数必须是整数
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
>>> bin(3.14)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
字符与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
常见的数学计算
>>> 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
3.输入与输出
input()
#num = int(input("
请输入一个数字
:"))
num
=
eval
(
input
(
"
请输入一个数字
:"
))
# input()
默认输入的是一个字符串
(
整行
)
print
(
num
+
1
)
"""
TypeError: can only concatenate str (not "int") to str
反向证明输入的是字符串
ValueError: invalid literal for int() with base 10: '123 456'
"""
# 处理一行内多个数据的输入
# eval处理的数据必须要有逗号分隔
# eval自动处理字符串解析
# eval既可以处理单值 也可以处理多值
"""
请输入两个数字
:123,456
579
"""
num1
,
num2
=
eval
(
input
(
"
请输入两个数字
:"
))
print
(
num1
+
num2
)
print()
print
(
"Hello World"
)
print
(
1
+
2
+
3
)
print
(
1
,
2
,
3
,
"Hello World!"
)
#
多数据输出 用空格分隔
print
(
1
,
2
,
3
,
sep
=
"#"
)
# sep
默认空格
print
(
1
,
2
,
3
,
end
=
"!!!"
)
# end
输出的解围 默认
"\n"
# 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
))
4.运算符
算术运算符
加法：数值相加，序列拼接
>>> 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
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
中 是不存在
++ --
这种自增运算符的！
int
i
=
1
;
i
++
;
System
.
out
.
println
(
i
);
System
.
out
.
println
(
i
++
);
int
j
=
i
++
;
System
.
out
.
println
(
i
);
System
.
out
.
println
(
j
);
i
=
i
++
;
System
.
out
.
println
(
i
);
i
=
i
++
;
System
.
out
.
println
(
i
);
i++
流程
1.
开辟临时存储区
2.
将
i
的值复制到临时存储区内
3. i
自身
+1
4.
临时存储区的值等待被调用（输出 赋值 参与运算）
System
.
out
.
println
(
x
++ + ++
x
+ ++
x
+
x
++
);
// 12
System
.
out
.
println
(
x
);
// 5
逻辑运算符
与 或 非
= 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
&&
就是为了避免一些没有必要的计算 提高效率
位运算符
在计算机编程中，按位运算是对整数在二进制表示下的位进行操作的一种技术。下面简单介绍几种常见的按位运算操作：
- 按位与（&）：
按位与运算符（&）用于对两个数的每一位执行逻辑与操作。如果两个操作数的对应位都为1，则结果位为1；否则为0。
例如：
a = 5 # 二进制表示为 0101
b = 3 # 二进制表示为 0011
c = a & b # 结果为 0001，即十进制为 1
- 按位或（|）：
按位或运算符（|）用于对两个数的每一位执行逻辑或操作。如果两个操作数的对应位有一个为1，则结果位为1；否则为0。
例如：
a = 5 # 二进制表示为 0101
b = 3 # 二进制表示为 0011
c = a | b # 结果为 0111，即十进制为 7
- 左移（<<）：
左移运算符（<<）将一个数的二进制表示向左移动指定的位数，右侧用0填充。每左移一位，相当于乘以2的n次方。
例如：
a = 5 # 二进制表示为 0101
b = a << 1 # 结果为 1010，即十进制为 10
- 右移（>>）：
右移运算符（>>）将一个数的二进制表示向右移动指定的位数，左侧用符号位填充（对于正数为0，负数为1）。每右移一位，相当于除以2的n次方取整。
例如：
a = 5 # 二进制表示为 0101
b = a >> 1 # 结果为 0010，即十进制为 2
- 取反（~）：
按位取反运算符（~）用于对一个数的每一位执行取反操作，即0变为1，1变为0。
例如：
a = 5 # 二进制表示为 0101
b = ~a # 结果为 1010，即十进制为 -6
- 异或（^）：
按位异或运算符（^）用于对两个数的每一位执行异或操作。如果两个操作数的对应位不同，则结果位为1；相同则为0。
例如：
a = 5 # 二进制表示为 0101
b = 3 # 二进制表示为 0011
c = a ^ b # 结果为 0110，即十进制为 6
按位运算通常用于一些底层操作，如位掩码、数据压缩等。在编写高效的算法时，掌握按位运算可以提供一些便利和效率上的优势。
关于变量交换值
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
418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
