Python 零基础入门

River Chandler

已于 2023-12-20 22:33:08 修改

阅读量1.9k

点赞数 2

分类专栏： Python语言程序设计方法与案例物理类专业竞赛专栏文章标签： python 开发语言

于 2022-10-07 21:43:59 首次发布

本文链接：https://blog.csdn.net/Chandler_river/article/details/127197856

版权

Python语言程序设计方法与案例同时被 2 个专栏收录

38 篇文章 2 订阅

订阅专栏

物理类专业竞赛专栏

8 篇文章 21 订阅

订阅专栏

写在前面

这绝对与你常见的入门指南不同，思路就不同，博主会先把Python当成一个计算器用
请多看看博主的其他文章。
今天是十月七号，是国庆的最后一天
为什么要写着一篇文章呢？因为我们学校要开始CUPT宣讲

从零开始

安装IDLE

Integrated Development and Learning Environment
新手为什么不用什么Pycharm或者Juypter或者VS或者VS Code呢？
- 也行，也行，都可以都可以但是博主不在这一篇文章里面讲
物理系同学第一次学编程就使用Python语言的害处
分不清楚得到快速的结果与快速得到结果的区别
- Python语言为什么慢是一个长久的话题。
- Python语言不能够解决绝大多数的问题
- Python语言不能够满足你和你的大龄导师和远古项目的交流
- Python语言在对精度要求较高的问题上的稳定性和准确性...
觉得编程很简单，然后被毒打
其他应当列为害处的害处

注释与转义符

Python 中的注释使用#或者三个引号
Python 不区分双引号和单引号，但是他们应该成对的使用

#注释

"""
    注释
"""

转义符是为了表示一些难以输入的特殊字符，不是什么希腊字母或者奇怪小符号，而是......

\n 回车换行
\t tab制表符
\\ 一个\字符
\" 代表一个双引号
\' 代表一个单引号

IDLE Shell 与 File 或者在命令行中运行

简单得说，你可以在IDLE Shell中运行简单的语句，但是为了使得你能高效率得记录和修改代码，你还是创建个New file写比较合适
请自行探索IDLE Shell的功能，这个教不了
- 在IDLE Shell中学习并运行这篇博客中展现出的代码，是方便的
- 一般来说 IDLE Shell中按 Enter 可以运行这行命令
- Alt + p 可以回滚到上一个命令
你可以自己创建任意一个文件，直接将后缀名改成 .py 我相信至少在Windows系统上你可以直接用IDLE打开这个文件并且开始码

赋值语句

赋值语句是指给任意一个变量赋值
Python中的变量指的是以非数字开头的，由数字，字母，字符串组成的一串序列（不正确的定义）
赋值所赋的值可以是任何Python中的对象
- 在目前来看，你并不需要知道对象的数据类型是什么
例如

a = 5
b = 10
a = b

a = b 的运行结果是使得 a = 5
- 在底层执行这行代码意味着一些地址转换或者什么高端的操作
- 你可以先熟悉这种感觉而不需要从机理上理解他

运算符与函数

Python中简单的运算符

按位运算符没有包括在内

# + 加法
# - 减法
# * 乘法
# / 除法
# ** 乘方运算  # 2**2 = 4
# % 取模运算
# == 判断是否等于
# != 判断是否不等于
# > 判断是否大于
# < 判断是否小于
# >= 判断是否大于等于
# <= 判断是否小于等于
# () 括号，没有中括号，大括号的区分，直接加即可

按位运算符

&	Bitwise AND Operator	10 & 7 = 2
\|	Bitwise OR Operator	10 \| 7 = 15
^	Bitwise XOR Operator	10 ^ 7 = 13
~	Bitwise Ones’ Compliment Operator	~10 = -11
<<	Bitwise Left Shift operator	10<<2 = 40
>>	Bitwise Right Shift Operator	10>>1 = 5

你学会的第一个函数应该是 print()

>>> print("start from zero")
start from zero

对于物理系的同学来说，什么程序结构，数据类型啥的，至少在Python语言的入门上你是不需要考虑这个问题的。当然，也只是在今天不考虑这个问题。进阶之后该补的还是要补，这篇文章只是能让你快速入门而不是掌握一门高级语言。
函数可以理解成 Input --> Output 即：fun(Input)
print函数可以将所有的Input输出到屏幕上，不论是字符串还是数还是一个对象

然后是简单的eval()函数

eval()函数可以将一个用引号括起来的Input转换成一个对象或者一串指令
eval()转换成一行指令

eval("1+2+3*4+5/10+0.25*2")
16.0

设计属于你自己的函数

你自己的设计由def <fun_name>(*args): 开始
这个最好在文件中编写 IDLE Shell中并不适宜，主要是不方便
例子如下
- 这个例子表示函数需要你输入两个数
- 这两个数会自动按照顺序分配给a,b
- 函数将会返回 1 * (a<0) + 1 * (b>0)
- a<0 表示当a的值小于零时，表达式的值为1 大于零的时候为1
- fun(1,2) = 1
警告：
- return 是函数的返回值，并不会被打印出来或者赋给一个变量，你需要手动操作
- 缩进在Python语言程序设计中有重要的作用
  - 缩进可以帮助你很多，不论是程序设计还是生活上，都很有帮助，尤其是你的思维方式上。当然，这样的思维方式会在未来限制你，所以，在学习完了Python语言后，你应该立即了解其他语言，类似于C，C++，C#，Java，Fortran等
  - 请自行感受缩进的妙处

def fun(a,b):
    return 1 * (a<0) + 1 * (b>0)

你很可能想要实现这样的效果

>>>c = fun(-1,1)
>>>c += 1
>>>print(c)
3

一些常见的内置函数

# sum() 求和函数
# max() 输出最大值
# min() 输出最小值
# abs() 输出绝对值

在大二学数理方法前，你不要考虑复数的问题
在做CUPT到一定的阶段之后，你需要考虑复数的问题，但我相信那个点你已经学会自学了

lambda

这是一个简化版的函数（错误的定义）

>>>y = lambda x:x**2+1
>>>c = y(2)
>>>print(c)
5
>>>y = lambda x,z:x**2+z
>>>c = y(2,1)
>>>print(c)
5

作用域与参数传递

作用域可以简单得理解为一个变量在程序的哪些地方是有效的
- 局部变量
- 全局变量
- 最好是在写代码的过程中学习......这不是三两句讲的清楚的
参数传递
- 可选的
- 名称传递

小结一

截至目前，你已经可以将Python当成一个攻读了低年级小学学位的同学手上的计算器用了，我相信这不是你的本意，但是很遗憾的是，短时间内你最好只掌握这些就好
如果想要给这个计算器增加一点什么微积分，线性代数的功能，请参考博主的其他文章，如

Scipy与Sympy,请放心，如果看到这里就去看那篇文章，大概也是能看懂的

博主相信，作为一个物理系的同学，你肯定学会了类推这一做法，这意味着你可以自己定义一个多变量的函数或者其他什么的

Python语言的组合数据类型

集合

集合内的元素具有独一性
集合不宜改动
集合用括号表示

a = (1,2,3,4,5)

序列

Python 很多都可以看成一个序列
比如一个字符串
```
string = "abcdefg"
```
比如一个列表
```
list = [1,2,3,4,5]
```
列表中的元素不受限制

索引

索引在Python语言中是从零开始的
索引在C系列的语言中也是从零开始的
相反的，很多上古的原因的索引不是从零开始的，比如FORTRAN
示例

>>>list = [1,2,3,4,5]
>>>list[2]
3

映射

主要指字典
```
dict = {"a":1,"b":2}
```
字典是没有索引的
字典的使用
```
>>>dict["a"]
1
```

小结二

好了，如果你看过其他的教程，你可能已经开始骂娘了，垃圾博主
想看更多有关组合数据类型的信息，请自行搜索，我相信你会找到的，或者看博主的 Python 函数，方法,错误类型和操作技巧大全

Python语言的语法元素与程序控制结构

分支控制结构

a = 10 
if a >= 9:
    a -= 5
elif a < 5:
    a += 5
else:
    a *= 3

####After run
>>>a
5

循环结构

for i in <可迭代的对象>:
    <do something>

while <判断表达式>:
    <do something>

异常处理

try:
    <do something>
except <Error type>:
    <do something>
finally:
    <do something>

总结与展望

很好，我相信你读完这些，看过了博主链接的两篇文章，一定已经可以大杀四方然后轻松过计算机二级了
然后我相信，你还需要学习还有很多，比如库，比如数据处理，比如面向对象，比如multiprocessing,比如数值分析，请看博主链接的其他文章

Python Numpy详解

Pandas 入门

Python time库、random库概览+Python里面有趣的东西

Python 并行化执行

xlrd 与 xlsxwritter 的基本操作+配合faker库

re模块 Python语言下的正则表达式

建一个属于你自己的Github账号吧
多上上CSDN吧，有好处的！
下面是 Python IDLE 中的一些快捷键

Ctrl + [    缩进
Ctrl + ]    取消缩进

Ctrl + Space 输入法切换（Windows）


Alt + 3     注释
Alt + 4     取消注释

Alt + /     补全单词（出现在上面的代码中的单词）
Alt + M     模块代码
Alt + C     类浏览器
Alt + FP    路径浏览器
Alt + DG    定位到错误行
Alt + DS    显示出错历史
 
Alt + p     前一个操作
Alt + n     后一个操作

F1          打开Python文档（可能是Fn + F1键一起）
F5          进入Shell调试（可能是Fn + F5键一起就是run的意思）

Ctrl + F6   重启Shell

有用的技巧

copy与deepcopy(Python3.10.3中)

deepcopy

将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。（原话来源于。。。反正非原创）

=等于赋值

当赋值是不可变对象（数值，字符串，元组）时，与deepcopy类似

>>> a = 100
>>> b = a
>>> a = 99
>>> b
100

当赋值是可变对象（列表，字典）时
- 不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。

>>> a = [1,2,3,4,5]
>>> b = a
>>> a.append(999)
>>> a
[1, 2, 3, 4, 5, 999]
>>> b
[1, 2, 3, 4, 5, 999]

copy

1）当浅复制的值是不可变对象（数值，字符串，元组）时和“等于赋值”的情况一样。

>>> a = 1231
>>> import copy
>>> b = copy.copy(a)
>>> a = 12313131
>>> b
1231
>>> 

>>> a = "1231"
>>> b = copy.copy(a)
>>> a = "123131"
>>> b
'1231'

2）当浅复制的值是可变对象（列表，字典）时有两种情况：

复制的对象中无复杂子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。

>>> a = [1,2,3,4,5,6,7]
>>> b = copy.copy(a)
>>> a.append(30)
>>> b
[1, 2, 3, 4, 5, 6, 7]

复制的对象中有复杂子对象 （例如列表中的一个子元素是一个列表），如果不改变其中复杂子对象，浅复制的值改变并不会影响原来的值。但是改变原来的值中的复杂子对象的值会影响浅复制的值。

>>> a = [1,2,3,[4,5,6],7,8]
>>> b = copy.copy(a)
>>> a.append(9)
>>> b
[1, 2, 3, [4, 5, 6], 7, 8]
>>> a[3][0] = 99
>>> b
[1, 2, 3, [99, 5, 6], 7, 8]
>>>

enumerate

a = ["1","2","3"]
a = enumerate(a)
for i,item in a:
    print("i:",i,"  ")
    print("item:",item)

    
i: 0   
item: 1
i: 1   
item: 2
i: 2   
item: 3

enumerate后只能使用一次

设计自己的ERROR

从 Exception 中继承

class MyError(Exception):
    def __init__(self,message):
        self.message = message

一个 raise Error 的函数

def check_visitor(name):
    admit = ["Eric","Li","Wangka"]
    if name not in admit:
        raise MyError(name + "没有权限")
    return name

try-except 结构

try:
    check_visitor("Sun")
except MyError as f:
    print(f)

从控制台运行文件 (Windows)

C:\Users\LX\Desktop>python c.py
Sun没有权限

哈希函数

hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary
hash值与对象的内容与内存地址相关

>>> hash("1")
-4822793638483448107
>>> hash("2")
1557982693971452354
>>> hash("3")
-6769686934220198669
class b():
    def __init__(self):
        pass

    
a = b
hash(a)
127701116725
a1 = b
hash(a1)
127701116725

动态生成变量

createvar = locals()
import random
random.seed(0)
class A():
    def __init__(self,i):
        self.initvalue = i*random.random()

for i in range(1,11):
    createvar["a"+str(i)] = i
    createvar["b"+str(i)] = A(i)
    
for i in range(1,11):
    print(eval("a"+str(i)))
    print(eval("b"+str(i)).initvalue)



>>>
1
0.8444218515250481
2
1.515908805880605
3
1.261714742492535
4
1.0356670011718534
5
2.5563736068430427
6
2.4296048247024857
7
5.486590123243408
8
2.4265018086314196
9
4.2893725873712025
10
5.833820394550312

把help的输出保存到文本文件中去

import scipy.optimize as so
import sys

out = sys.stdout
sys.stdout = open(r"c:\Users\LX\Desktop\scipy.optimize帮助文档.txt","w")
help(so)
sys.stdout.close()
sys.stdout = out

进度条显示（网络上流行的一种方法）

import time
t = 60
print("**************带时间的进度条**************")
start = time.perf_counter()

for i in range(t + 1):
    finsh = "▓" * i
    need_do = "-" * (t - i)
    progress = (i / t) * 100
    dur = time.perf_counter() - start
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(progress, finsh, need_do, dur), end="")
    time.sleep(0.05)
input("enter to exit")

Numpy 按某一列排序

a = [[2,3,1],[23,231,53],[8,67,56]]
a = np.array(a)
b = a[:,0]
index = np.lexsort((b,))
a[index]
array([[  2,   3,   1],
       [  8,  67,  56],
       [ 23, 231,  53]])

列表加速

List = []        
start = time.time()
##f1 = List.append
for i in range(20000000):
##    f1(i)
    List.append(i)
end = time.time()
print(end-start)