如何运行Python脚本文件呢
打开
CMD
窗口，进入到代码目录路径
指令：
python XXX.py
运行
XXX.py
文件
或者
找到Terminal中的New Terminal
1.6基本数据类型
讲数据类型前我们要先谈谈编程规范
- 标识符
就是我们程序员自定义的一些名称（变量 函数 类）
规则：
由字母、数字、下划线、美元符组成
数字不能开头是一个连续的词，中间不能有空格分开
规范：
小驼峰：
变量 函数
多个单词出现时 第一个单词首字母小写 之后单词首字母都大写 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 * _ooOoo_
3 * o8888888o
4 * 88" . "88
5 * (| -_- |)
6 * O\ = /O
7 * ____/`---'\____
8 * .' \\| |// `.
9 * / \\||| : |||// \
10 * / _||||| -:- |||||- \
11 * | | \\\ - /// | |
12 * | \_| ''\---/'' | |
13 * \ .-\__ `-` ___/-. /
14 * ___`. .' /--.--\ `. . __
15 * ."" '< `.___\_<|>_/___.' >'"".
16 * | | : `- \`.;`\ _ /`;.`/ - ` : | |
17 * \ \ `-. \_ __\ /__ _/ .-` / /
18 * ======`-.____`-.___\_____/___.-`____.-'======
19 * `=---='
20 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
21 * 佛祖保佑 永无BUG
22 * 佛曰:
23 * 写字楼里写字间，写字间里程序员；
24 * 程序人员写程序，又拿程序换酒钱。
25 * 酒醒只在网上坐，酒醉还来网下眠；
26 * 酒醉酒醒日复日，网上网下年复年。
27 * 但愿老死电脑间，不愿鞠躬老板前；
28 * 奔驰宝马贵者趣，公交自行程序员。
29 * 别人笑我忒疯癫，我笑自己命太贱；
30 * 不见满街漂亮妹，哪个归得程序员？
31 """
Python能够操作的数据都有哪些
- 常量
- 整数常量
不能够改变的量-字面量
>>> print(10) #十进制
10
>>> print(0b1001) #二进制 binary
9
>>> print(0o12) #八进制 Oct...
10
>>> print(0x12) #十六进制 Hex...
18
注意：没有byte short long 之分 一律默认int
- 小数常量
>>> print(1.34)
1.34
>>> print(0.12e10) #0.12*10^10
1200000000.0
注意：没有float与double之分 默认float
- 字符串常量
字符串表示一段文本信息，程序会将文本信息原封不动的处理
>>> 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("张老师说:'好好学习'")
张老师说:'好好学习'
- 布尔值常量
只有两个值 True，False，T和F是大写的
>>> print(True + 1)
2
>>> print(False + 1)
1
True如果参与运算默认为1 False默认为0
- 复数常量
数学运算常用到
复数常量可以直接通过书写其标准形式 a + bj 创建，例如 3+4j，这在解释器中会被识别为一个复数类型的对象。同时，也可以通过 complex(a, b) 函数构造复数，其中 a 是实部，b 是虚部。复数的这种内建支持使得在实际编程过程中能够方便地对复数进行各种算术运算和其他数学操作
>>> 1+2j
(1+2j)
>>> complex(1,2)
(1+2j)
>>> (1+2j)*(1-2j)
(5+0j)
- 变量
在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
补充：
- 内置函数名**/**类名
内置函数就是Python自带的一些具有特殊功能的函数
>>> 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
1.7数据转换
1.7.1 int()
将其他有效的数据转为整数
- 取整
- 从字符串中解析整数
>>> int(3.14) # 将小数进行取整操作
3
>>> int("123") # 将数字字符串进行解析（默认十进制），解析出一个整数
123
>>> int("AD", 16) # 将数字字符串进行十六进制解析，结果都是十进制
173
# 10*1
>>> int("91A", 12)
1318
>>> 10 * 12 ** 0 + 1 * 12 ** 1 + 9 * 12 ** 2
1318
>>> int("A1F", 13)
Traceback (most recent call last):
>>> 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
1.7.2 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
1.7.3 str()
将其他数据转字符串
>>> str(123)
'123'
>>> str(3.14)
'3.14'
>>> str(print)
'<built-in function print>'
1.7.4 bool()
将其他数据转布尔类型
>>> 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
注意：记住空串是False，简化编程
1.7.5 bin() oct() hex()
进制转换
>>> 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
1.7.6 ord() chr()
字符与ASCII码转换
ord()：获取字符对应的ASCII码编号
>>> ord('a')
97
>>> ord('A')
65
>>> ord('0')
48
chr()：根据给定的ASCII码编号获取对应的字符
>>> chr(98)
'b'
>>> chr(57)
'9'
1.7.7 abs() pow() max() round()
常见的数学计算
>>> 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
>>> round(3.123456 , 2) #四舍五入保留小数点后两位
3.12
round()在函数调用时返回要求保留两位小数就应使用给两个参数的“构造函数”—>
round(a , b)
1.8输入与输出
1.8.1 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)
a, b, c = map(int , input("请输入三个数中间用空隔分隔").split())
1.8.2 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))
1.9运算符
1.9.1 算术运算符
- 加法：数值相加，序列拼接
>>> 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
对应周六
1.9.2 布尔判断运算符
运算结果一律为布尔值
大于 小于 大于等于 小于等于 不等于 等于
< >= <= != ==
Python允许连续比较
>>> 1 < 2 < 3
True
>>> 1 < 2 and 2 < 3
True
在Python当中 == 到底比得是啥？
答：比的是具体对象的值
在Java中 == 比较的也是内容，对于引用数据类型的比较要用
equals()
，比较地址
>>> 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存的地址一样
1.9.3 增强型赋值运算符
+= -= *= /= //= **= %=
a += 2
a = a + 2
b **= 2
b = b ** 2
额外多说一句：在Python中 是不存在 ++ --这种自增运算符的！
i++流程
开辟临时存储区
将
i
的值复制到临时存储区内
i
自身
+1临时存储区的值等待被调用（输出 赋值 参与运算）
System.out.println(x++ + ++x + ++x + x++); // 12
System.out.println(x); // 5
1.9.4 逻辑运算符
与 或 非
= 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.9.5 位运符
& | >> << ~ ^
&按位与
>>> 13 & 7
5
1101
0111
0101 = 5
|按位或
>>> 13 | 7
15
1101
0111
1111 = 15
>> 右移
>>> 16 >> 2
10000
100|00
100 = 4
16 / 2 ^ 2
<< 左移
>>> 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
1.9.6 成员运算
in 和 not in
判断一个元素是否在另一个序列中
>>> "abc" in "sakjdgjhsgadugashjdvasvdjgsa"
False
>>> "abc" in "sakjdgabca"
True
>>> 1 in [2,3,4]
False
1.9.7 从属/身份运算符
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
1.10条件判断
只有
if-else
语句，
Python
不支持
switch
语句
# 单if语句
if 条件语句:
条件为真时执行的内容
# if-else语句
if 条件语句:
条件为真时执行的内容
else:
条件为假时执行的内容
# if-elif语句 else if
if 条件语句1:
条件语句1为真时执行的内容
elif 条件语句2:
条件语句2为真时执行的内容
elif ....
else:
所有条件都不满足时执行的内容
# 语句嵌套
if 条件1:
if 条件2:
执行内容(1和2都满足)
else:
执行内容(满足1不满足2)
else:
执行内容(1和2都不满足)
1.11循环语句
主要解决什么样的问题：具有重复性、规律性的问题
向前走
10
步：有明显的循环次数的
- for
向前走，直到碰墙为止：没有明显的循环次数的，但是有结束条件
- while
循环四要素：
- 循环的开始（从第1步开始；从第1步开始/从起点开始）
- 循环的继续条件（还没走到第10步；没有碰到墙/就是看距离）
- 循环体（走的每一步；走的每一步）
- 循环的步长/间隔/周期/进度（步数的统计；距离的统计）
for i in range(11):
print(i)
"""
range(n) : 取值范围是[0,n) 步长默认为1
0 1 2 3 4 5 6 7 8 9 10
i
循环的开始：0
循环的继续条件：i < n
循环体：print(i)
循环的步长:步长默认为1
"""
for i in range(2, 10):
print(i)
"""
range(a, b):取值范围[a, b) 步长默认1
"""
for i in range(2, 13, 2):
print(i)
"""
range(a, b, c):取值范围[a, b) 步长默认2
"""
print("="*12)
for i in range(100, 1):
print(i)
for i in range(100, 10, -10):
print(i)
"""
range(a,b,c)
如果c > 0, a < b 才是有效范围 递增
如果c < 0, a > b 才是有效范围 递减
"""
# 特殊的 结合序列去使用 遍历序列中每一个元素
for i in "abcdefg":
print(i)
- 循环嵌套
双层嵌套的循环中，外层循环控制打印的”行“，内层循环控制打印的”列“
若想要实现打印图形的左右对称，可以在内层循环中考虑用绝对值的思想
同理若要实现打印图形的上下对称，可以在外层循环中考虑用绝对值思想
n = eval(input("请输入层高"))
#外层循环控制行
for m in range (- n // 2 , n // 2 + 1):
#内层循环对列进行把控
for i in range(abs(m)):
print("" , end = " ")
for j in range(n // 2 + 1 - abs(m)):
print("*" , end = " ")
print()
1.12数组列表
- 序列：存储一堆数据的集合/容器
- 序列的类型包括：列表、字符串、元组、集合、字典
1.12.1 序列概述
序列（Sequence）是指一种有序的数据结构，其中包含了一系列具有固定顺序的元素。每个元素在序列中都有一个确定的位置，可以通过索引进行访问
- 序列的通用操作：
索引/角标
>>> arr = ["a" , "b" , "c" , "d" , "e" , "f" , "g" , "h" , "i"]
>>> arr[0]
'a'
>>> arr[8]
'i'
>>> arr[-1] #倒数第一个
'i'
>>> arr[-9] #倒数第九个
'a'
>>>
#你试图访问的位置超出了列表实际内容的末尾
>>> arr[-100]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> arr[100]
Traceback (most recent call last):
**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**
**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**
**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**
**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**
Sequence）是指一种有序的数据结构，其中包含了一系列具有固定顺序的元素。每个元素在序列中都有一个确定的位置，可以通过索引进行访问
* 序列的通用操作：
**索引/角标**
arr = [“a” , “b” , “c” , “d” , “e” , “f” , “g” , “h” , “i”]
arr[0]
‘a’
arr[8]
‘i’
arr[-1] #倒数第一个
‘i’
arr[-9] #倒数第九个
‘a’
#你试图访问的位置超出了列表实际内容的末尾
arr[-100]
Traceback (most recent call last):
File “”, line 1, in
IndexError: list index out of range
arr[100]
Traceback (most recent call last):
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-ExZnonxP-1713659177920)]
[外链图片转存中…(img-W99a9NrT-1713659177921)]
[外链图片转存中…(img-fY0IwMyk-1713659177921)]
[外链图片转存中…(img-E6Fg4qNt-1713659177922)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
