文章目录
现在不是一直都在吹
Python吗，说什么小学都要出Python的教材了，搞得好像这年头不会个Python还不如小学生一样！
既然如此，那么？你会Python吗？
不会？不要紧！一篇文带你入门Python！一篇文带你疏通Python基础语法！
会？行吧，别急着走嘛！看看吧。毕竟，温故而知新，可以为师矣！
Python作为一门高级编程语言吗，最大的特点就是简单易学
来看看Python是如何在C/C++，Java等语言中脱颖而出的吧
由于Python的第三方类库实在是太多了，因此它能做的事情也是极多的，甚至你也可以自己做一些类库放在网上让别人使用。
这其一呢，Python可以做我们的PC客户端，也就是PC端的QQ，百度网盘之类的需要下载安装的软件
这其二呢，Python还能做点PC端的小游戏，比如什么植物大战僵尸，魂斗罗，飞机大战的
这其三呢，Python还能搭建网站，做我们经常用的类似于百度，CSDN，华为云社区这些
这其四呢，Python还可以做网络爬虫，就是不需要我们手动的去网络上下载数据，代码一键把 所有数据拿下来（当然也很有风险）
这其五呢，Python可以做数据分析，就是把我们从网络上爬取的数据进行分类，放在一起，便于查询，把我们不需要的数据丢掉之类的
这其六呢，Python还可以做AI，也就是人工智能
这其七呢，Python可以做自动化办公，也就是自动填写表格，自动处理数据之类的
这其八呢，Python还可以做自动化运维
当然除了这些，还能做些别的，我就不一一道来了，因为一个人精力有限，也是没法全部学完的，就说这么多吧
…
可以去官网下载——
官网下载后傻瓜式安装，不过有一步需要注意的是：Add to path的地方需要勾一下
不勾选的话需要手动配置环境，异常麻烦
安装好以后，我们
Ctrl + R
输入
cmd
打开命令行
在命令行输入我们所学语言的名字：
python
会看到这个符号：
>>>
这个就是Python自带的交互模式
而我们只需要输入
print("HelloWorld")
就能让计算机给我们显示一个HelloWorld出来
而在括号里面，引号里面，我们可以进行修改，来改变屏幕显示的内容
引号的意思：引号在Python里面是有字符串的意思
当然，你也可以在括号里面输入1+1等运算来让计算机给你计算结果
顾名思义，输入就是你用键盘输入，输出就是计算机输出给你内容
输入我们需要用到一个内置函数：
input()
汉语意思也是输入，在Python中的作用也是输出
觉得不好理解可以这么理解：
input()表示我对电脑说的话
输出我们需要用到一个内置函数：
print()
汉语意思是打印，就是打印内容到你的屏幕上
而这个print函数，也是我们HelloWorld入门实战的函数
print()表示电脑对我说的话
设计一个小程序实现输入什么内容就输出什么内容
代码：
print(input())
# 意思是在输出函数里面使用输入函数 看着很简单，但是其实还设计了函数返回值的知识，这里就只提一下
在input()函数的括号里可以像print()函数一样写东西，他会在你运行代码之后显示
你可以用这个来设置输入的提示信息
每个语言都有自己的语法，不同语言的语法也不尽相同
在别的语言中使用大括号来表示一个代码块
而在Python中使用缩进来规定一个代码块
缩进一般以四个空格为标准
缩进错误会报错显示语法错误
错误缩进：
print("aa")
print("bb") 正确缩进：
print("aa")
print("bb") 给自己的程序添加注释是很有必要的
俗话说得好：
程序员最讨厌给自己的代码写注释，更讨厌别人的代码不写注释
- 单行注释
-
- # 我是单行注释
- 多行注释
-
- “”“多行注释”""
- ‘’‘多行注释’’’
两种多行注释都能当字符串使用
一定要养成写注释的好习惯，这很重要
- 程序员自己命名的
- 有自己的规范
-
- 包含数字，字母，下划线
- 不能以数字开头
- 大小写敏感
- 一般采用驼峰命名法
-
-
- 首字母小写，其他单词首字母大写
- peopleName这样
-
-
- 类名建议首字母大写
一定要遵循规范，这很重要
- 官方规定的具有某种特定意义的单词
- 标识符不能用保留字
- Python有33个保留字
- 也叫关键字
- 所有符号都用英文半角符号
诸如def class等不是内置函数的单词
def class if for while 等等等 值无法改变的量
- 例如数字1
- 例如字符串"hello world"
- 等等
print(1) 值能改变的量
- 名字为标识符
- 使用赋值符号 = 给变量复制
-
- a = 1这样
a = 1
b = "www"
print(a,b)
# 1www - 加：+
- 减：-
- 乘：*
- 除：/
print(1+1) # 2
print(10-2) # 8
print(10*2) # 20
print(10/2) # 5 - 大于：>
- 小于：<
- 大于等于：>=
- 小于等于：<=
print(1==2) # False
print(1>2) # False
print(10>=5) # True
print(5<=1) # Fasle - 直接赋值：=
- 相加赋值：+=
- 相乘赋值：*=
i = 10 # 给i赋值为10
print(i+=1) # 让i加1
print(i*=2) # 让i乘2 - 整型
-
- 1
- 100
- 浮点型
-
- 1.1
- 10.1
- 布尔型
-
- True
- False
- 复数类型
-
- 5j+1
- 1+3j
- “hello”
- ‘hello’
- ‘’‘hello’’’
- “”“hello”""
"""
例子：给出一个变量a = 1 怎么让输出的结果为：“a的值为：1”
第一个方法：print(“a的值为：”, a)
第二个方法：print(“a的值为：{}”.format(a))
第三个方法：print(“a的值为：%d”%a)
第四个方法：print(f"a的值为：{a}")
其实就是让我们的字符串中可以添加变量，而第一种的方法在处理一个字符串中的多个变量时是较为麻烦的，这时候就需要用到下面三个，比较简单，我最喜欢的是第四个方法。因为写出来简单
"""
a = 1
print(“a的值为：”, a)
print(“a的值为：{}”.format(a))
print(“a的值为：%d”%a)
print(f"a的值为：{a}")
# 原生字符串和非原生字符串
# 看代码看差异
# 1. 原生字符串
print(r'\n\t')
# 2. 非原生
print('\n\t') - [1, 2, 3, 4]
- [‘a’, ‘b’, ‘c’, ‘d’]
- [True, False, False]
增删改查：
li = [1, 2, 3, 4]
li.append(5) # [1, 2, 3, 4, 5]
li.remove(5) # [1, 2, 3, 4]
li[0] = 10 # # [10, 2, 3, 4]
print(li[0], li[1]) - (1, 2, 3, 4)
- (‘a’, ‘b’, ‘c’, ‘d’)
增删：
tu = (1, 2, 3, 4)
tu1 = (5,)
tu2 = tu+tu1 # (1, 2, 3, 4, 5)
del tu # 全部删除 - {‘a’: 1, ‘b’: 2}
- {1: ‘a’, 2:‘b’}
dic = {'a': 1, 'b': 2}
dic['c'] = 3 # {'a': 1, 'b': 2, 'c': 3}
del dic['c'] # {'a': 1, 'b': 2}
dic['a'] = 10 # {'a': 10, 'b': 2}
print(dic['a']) # 10 - (‘a’, ‘b’,‘c’)
se = {1, 2, 3, 4}
se.add(5) # {1, 2, 3, 4, 5}
se.remove(5) # {1, 2, 3, 4}
se.clear() # 全部删除 下面的可以用下标来访问该下标的值，下标从0开始
print("hello"[0]) # h
print([1, 2, 3, 4][1]) # 2
print({1, 2, 3, 4}[2]) # 3
print((1, 2, 3, 4)[3]) # 4
# 下标：0 1 2 3
print({'a': 1, 'b': 2}['a']) # 1
# 字典以键取值，前面是键，后面是值 对这些类型取某些值，而不是单一的值
print("hello"[0:2]) # 切片出he
print([1, 2, 3, 4][0:3:2]) # 从下标0到3每二个取[1, 3]
# print({1, 2, 3, 4}[0:1] # 会报错，因为集合具有无序性
print((1, 2, 3, 4)[3]) for i in range(10):
print(i)
# 也可以对高级数据类型进行这样的操作
a = "Hello World!"
for i in range(10):
print(a) i = 0
while i<10:
print(i)
# 也可以对高级数据类型进行这样的操作
a = "Hello World!"
i = 0
while i<10:
print(a[i])
i+=1 a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
print("两数之和小于10")
7.2.2 if…else…
a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
print("两数之和小于10")
else:
print("两数之和大于10")
7.2.3 if…elif…elif…else…
a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
print("两数之和小于10")
elif c==10:
print("两数之和等于10")
else:
print("两数之和大于10")
- 打破分支语句
- 使分支语句终止
while True:
a = input()
if a == "q":
break
else:
print(a + " 输入成功，输入 'q' 退出程序")
- 跳过分支语句
- 进行下一次分支语句
for i in range(10):
if i % 5 == 0:
continue
else:
print(i) - 减少代码重用率
- 加快开发效率
使用关键字：def定义
# 定义
def Qinghua():
print("我爱你")
print("我要给你生猴子")
print("啊啊啊，好喜欢你")
# 调用
Qinghua()
def fun():
print("我是无参函数")
fun() def PinJie(a, b):
str_ = str(a)+str(b)
print(str_)
for i in str_:
print(i)
PinJie("sasa", 4564)
#也可以这么写
"""
PinJie(a="sasa",b=4564)
这样写的好处是
就算你的位置写错了
参数传递的也还是对的
也就是说，参数传递的位置不固定
就像这样
PinJie (b=4564, a='sasa')
是完全一样的
""" -
return
用于将函数变成变量使用
函数名字(参数)
def PinJie(a, b):
str_ = str(a)+str(b)
return str_
p = PinJie("sasa", 4564)
print(p)
- 效率高
- 简单
- 不易维护
- 开发效率较面向对象低
- 提升开发效率
- 增加维护性
-
定义抽象化的类
既实例化对象
使用class关键字定义
- 三种定义方法
class Person1:
pass
class Person2():
pass
class Person3(object):
pass
# 使用实例化对象
p1 = Person1()
p2 = Person2()
p3 = Person3() def __init__(self):
pass
# 给类传参
class Person3(object):
def __init__(self, name, age):
pass
p3 = Person3('a', 12) - 在构造方法里self.属性 = 属性
- 在属性名前面加 _
- 在方法名前面加 _
# 在构造方法里self.属性 = 属性
class Person1(object):
def __init__(self, name, age):
self.name = name
self.age = age
Menger = Person("萌杰尔", 20)
name = Menger.name
age = Menger.age
print("姓名：{} \n年龄：{}".format(name, age))
# 在属性名前面加 _
class Person2(object):
_weight = 70
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
def weightPrint(self):
print("我的体重是：", self._weight)
person = Person("布小禅", 20, 180)
person.weightPrint()
# 在方法名前面加 _
class Person3(object):
def _love(self):
print("我暗恋Xxx")
def speakLove(self):
self._love()
- 在定义类的时候，写在类名后面的括号里
-
Python支持多继承
class Person(object, class1, class2): pass
- 继承后，该类拥有所继承的类里面的所有方法和属性
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def speak(self):
print(f"{self.age}岁的{self.name}会说话")
class Boy(object,Person):
pass
boy = Boy ("Menger", 20)
boy.speak() - _init_ 构造方法
- _str_ 使实例化对象变成字符串
- _new_ 先于构造方法被执行
- _call_ 使实例化对象拥有函数性质
- _del_ 实例化对象被删除时执行
class Person(object):
def __str__(self):
return "我是__str__方法的返回值，显示在打印实例化对象时"
def __del__(self):
print("我没用了，我被删除了")
def __new__(cls):
print("我是__new__方法")
return super().__new__(cls)
def __call__(self):
print("执行了__call__方法")
return "我是返回值"
p = Person()
print(p) - try:…except:…finally:…冒号后面接回车
-
- try后面跟有可能错误的代码
- except后面跟如果错了怎么办
- finally后面跟不管错没错都要执行的代码
try:
print(a)
except:
print("小伙子，我不认识什么是a啊")
finally:
print("好好写代码，不要老是报错了啊") - 内置函数open()
-
- open(“文件名”, “读取方式”)
-
-
- w只写
-
- r只读
-
- w+读写
- wb以二进制写
-
- rb以二进制读
- wa追加写入
"""
测试文件为text.txt
内容为：
我是text.txt
我的作用是测试文件操作
"""
f = open('text.txt', 'r', encoding='utf-8')
# 用变量接收，以便于后面的操作
ree = f.read() # 读取全部
li = f.readlines() # 按行读取全部行
rre = f.readline() # 只读取一行
# 测试三个函数，运行的时候，记得把别的注释掉
# 原因是第一个函数已经把文件的指针挪到最后了，第二个函数就读不到东西
print(ree)
f.close()
# 使用完记得关闭文件，免得消耗资源，使得程序报个内存溢出的错
f = open('text.txt', 'w', encoding='utf-8')
f.write("我是使用write函数写入的")
f.close()
# 这个方法会覆盖原来的，想继续写，只能使用追加方式
f = open('text.txt', 'wa', encoding='utf-8')
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.close() 路径，文件，sys
参考我之前的博客：
os模块的简单使用计时，时间
import time
start = time.time() # 当前时间戳
a = 1000**100000
end = time.time() # 获取计算完成的时间戳
runTime = end - start # 计算所花的时间
print("本次计算耗时：{}".format(runTime)) 随机数
import random
# 生成10个0-10的证书
for i in range(10):
print(random.randint(0,10))
# 生成10个0-1的数
for i in range(10):
print(random.random()) 正则表达式
"""
正则表达式用于提取字符串中的某些数据
"""
import re
# 定义一个字符串
a = "大连科技动拉网红豆味"
# 提取科技两个字
print(re.findall("大连(.*?)动", a)) 要先了解进程，线程的区别
- 进程：
拿电脑举例子的话，进程就是QQ，微信等不同的程序
拿py文件举例子的话，就是你的多几个py文件
- 线程：
拿电脑举例子的话，就是QQ，微信里你能和好多人一起聊天
拿py文件举例子的话，就是你在py文件里的许多函数
多线程具有无序性：
既任务不会按顺序完成
import threading
def speak(a=list):
for i in a:
print("我是",i,"\n")
li = [1, 2, 3, 4, 5, 6, 7]
li2 = ['1', '2', '3', '4', '5', '6', '7']
s1 = threading.Thread(target=speak, args=(li,))
s2 = threading.Thread(target=speak, args=(li2,))
s1.start()
s2.start() 运行结果：
"""
我是 1
我是
我是1 2
我是
我是2 3
我是 3
我是
我是4 4
我是5 5
我是
我是6 6
我是
我是7 7
""" class MyThead(threading.Therad):
def __init__(self,n):
super(MyThread,self).__init__() #重构run函数必须写
self.n = n
def run(self) -> None:
speak(li)
speak(li2)
return super().run()
def speak(a=list):
for i in a:
print("我是",i,"\n")
li = [1, 2, 3, 4, 5, 6, 7]
li2 = ['1', '2', '3', '4', '5', '6', '7']
s1 = MyThead('1')
s2 = MyThead('2')
s1.start()
s2.start() 如果不设置守护线程，那么主线程退出后，其他线程仍会执行直到执行完毕才会退出
线程默认不是守护线程，设置守护线程的方法是设置线程函数的参数daemon=True
import threading
def speak():
print("aaa")
t1 = threading.Thread(target=speak, daemon=True)
t2 = threading.Thread(target=speak)
t3 = threading.Thread(target=speak) 使用Python链接数据库
import pymysql
pymsql.connect(host='127.0.0.1',port=3306, user='你自己的账号', passwd='你自己的密码', db='你的数据库') 执行语句：
# 获取游标
cos = con.cursor(pm.cursors.DictCursor)
sql = cos.execute("select * from 你自己的数据表")
# 查看查询结果
print(sql) 关闭连接：
con.close()
cos.close() 模块是一个py文件
我们自己创建一个py文件就是一个模块
我们可以对他进行导入的操作，然后使用
- 自定义模块：textmodel.py
def print_f(a):
print(a)
-
另一个py文件：模块.py
导入的时候记得要让两个文件同路径
我们导入自定义模块，然后使用自定义函数
# 第一种方法
import textmodel
textmodel.print_f("第一种方法：直接导入 测试成功")
# 第二种方法
from textmodel import print_f
print_f("第二种方法：精确导入某函数 测试成功")
# 第三种方法
import textmodel as tm
tm.print_f("第三种方法：导入起别名 测试成功") 导入别人的模块和内置模块也可以这样
项目文件夹：
包就是一个含有
__init__.py
的文件夹
我们在项目目录下创建一个文件夹
text
，然后在里面放一个
__init__.py
的文件
这样就是一个包了
- 在text文件夹新建一个
textpackage.py
def print_f(a):
print(a) - 和text同目录的
模块.py
from text import textpackeg
textpackeg.print_f("包测试成功") text文件夹：