Python基础 (v3.6.6)
pycharm相关设置：
1.左侧字体：设置-Appearance & Behavior -Appearance -Theme选择Intellij为白色，
勾选第2个，选18号
2.代码大小：Editor -Colors & Fonts -Font -Scheme选择Default为白色，字号设置26
3.运行结果大小：Editor - Colors & Fonts - Console font ，字号设置26
4.解释器：Project xx - Project Interpreter
第一部分---------------------------------------------------------------------
python安装
1.注意环境变量的配置
2.验证：DOS窗口输入：python -V
3.python 文件格式为 .py
1.注释：解释说明，不会被程序执行
1.单行注释用#，正常是写在代码上方
2.多行注释用一对三引号（单、双引号都可以）
2.输出 print()
print(666)
print('hello, world')
print("你好")
1.不换行输出
print("hello, world2", end =" ")
2.换行输出
print() #空一行
3.变量
name = '小明'
age = 20
weight = 55.56789
print('我叫',name,',今年',age)
print('我叫' + name,',今年'+ str(age))
1.格式化输出
%s：字符串
%d：整型
%f：浮点型
print('我叫%s'%name)
print('我叫%s,今年%d,体重%.2f'%(name,age,weight))
2.变量赋值：把等号右边的值赋给左边变量
# 普通赋值
a = 666
# 链式赋值
a = b = c = 6
print(a,b,c)
# 序列解包赋值
a,b,c = 1,2,3
print(a,b,c)
3.变量命名规则：
1.变量必须赋值才能使用
2.变量名可以包括字母、数字、下划线，但变量名不能以数字开头。
3.字母可以是大写或小写，但大小写是不同的。
4.等号（=）是赋值的意思，左边是名字，右边是值，不可写反咯。
5.变量命名遵循驼峰命名法，如 userName，也可以user_name
练习：假设变量 a = 3, b = 4 如何将a，b两个变量的值互换
a,b=3,4
a,b=b,a
print(a,b)
4.输入input()
name = input('input your name:')
print('you are',name)
注：凡是从键盘输入的数据，系统都默认为 字符串(str) 数据类型
5.查看数据类型 type()
int：整型(可以理解为整数)，如123,20
float：浮点型（可以理解为小数），如 3.14
str：字符串，如 'tom'，"杰瑞"
6.数据类型转换：
int(a) ：把变量a转换成整型
float(a) ：把变量a转换成浮点型
str(a)：把变量a转换成字符串
注意：字母是无法转换为整型和浮点型的数据类型的。
练习：从键盘输入两个整数，然后计算出他们的和
a= int(input('请输入第1个整数：'))
b= int(input('请输入第2个整数：'))
print('两个整数的和是：',a+b)
7.字符串相关
1.拼接：适用于字符串
a='hello'
b='world'
print(a+b) →：helloworld
2.缩进 \t
print('qqq\thaha')
3.换行 \n
print('qqq\nhaha')
4.转义符 \ 将特殊字符失去原有意义
print('let\'s go')
print("let's go")
5.原始字符串
在字符串前面加r或R
c = R'C:\now'
print(c)
6.字符串索引
c = 'helloworld'
print(c[1]) →：e
print(c[0:3]) →：hel 从0开始，不包括3
7.反转输出
c = 'helloworld'
print(c[::-1]) →：dlrowolleh
print(c[-1:-4:-1]) → dlr 从倒数第1位开始，到倒数第3位结束
8.统计字符串长度 len()
print(len(c))
9.判断一个字符串是否在另一个字符串内
'a' in 'asd' →：True
'a' not in 'asd' →：False
8.常见的算术运算
+：加法，拼接字符串
-：减法
*：乘法，字符串的倍数输出
/：除法
**：幂
//：取商的整数部分（地板除）
%：取商的余数部分
9.逻辑操作符
and 、not、 or
1、 and操作符，and两边都为true时，返回true，否则返回false
2、 not操作符，取相反的not true 就是false
3、 or操作符，当两边有一边返回true，返回true
name = 'tom'
print('t' in name and 'o' in name)
print(not 't' in name)
print('tt' in name or 'o' in name)
10.运算优先级
幂 > 正负号 > 算术操作符（加减乘除、取余、取整）> 比较运算符（大于小于、<=、==、!=）
> 逻辑运算符（and、or、not）
11.列表 list
能够将所有看见的东西存放进去，可以把列表看成一个仓库，他可以用来存放所有数据。
在Python中，列表用[]表示，中间的每一项用,分隔开,列表中可以存放任何东西，
甚至可以存放另一个列表
1.定义列表
list1= [] # 空列表
list2 = [666,'hello','杰瑞'] # 非空列表
2.列表访问
list2 = [666,'hello','杰瑞',[777],55,66,7]
print(list2)
print(list2[2]) # 列表的访问，下标从0开始，取下标2
print(list2[1:3]) # 切片访问
print(list2[::]) # 打印所有
print(list2[::2]) # 以步长2打印所有
print(list2[1:5:2]) # 以步长2打印下标1到5-1
print(list2[::-1]) # 反转输出
print('hello' in list2) # 判断元素是否在列表
3. 统计长度 len(list2)
4.列表元素的增，删，改
list2.append('橘子') # 在列表尾部增加元素
print(list2)
list2[1] = 'world' # 修改元素
print(list2)
del list2[5] # 删除指定元素
print(list2)
del list2 # 删除整个列表，删除后无法访问
list2.remove(100) # 删除列表指定元素
list2.remove('tom') # 删除列表指定元素
5.使用列表内置的 sort()方法进行升序
list3 = [66666,55,3.14,66,7]
list3.sort() # 排序只对数字有效，sort()方法会改变原列表顺序
print(list3)
print('-'*20)
list3 = [66666,55,3.14,66,7]
print(sorted(list3)) # sorted不会改变原列表顺序
print(list3)
如果降序呢？
# 练习：定义一个整数列表，并降序排序
list2 = [23,56,15,39,5]
list2.sort(reverse=True) # reverse表示颠倒的意思
print(list2)
list2 = [23,56,15,39,5]
list2.sort()
print(list2[::-1])
list2 = [23,56,15,39,5]
print(sorted(list2)[::-1])
6.列表的常用操作符 in 、 not in
print(66 in list5)
print(55 not in list5)
a = 55 in list5
print(a)
补充（了解即可）：
1.print(list1.count(9)) # 统计元素9出现的次数，字符串也适用
a = 'hello' →： hello
b = [a] →： ['hello']
c = list(a) →： ['h', 'e', 'l', 'l', 'o']
12.不同的列表---元组tuple
元组与列表最大的区别，元组的内容是无法改变（无法新增、删除、修改）
tuple1 = () 或tuple1 = tuple() # 定义空元组
print(tuple1)
tuple2 = (6,) # 定义1个元素的元组
print(tuple2)
tuple3 = (6,777,'dasdas') # 定义多个元素的元组
print(tuple3)
元组的访问与字符串、列表都是一样的额
13.条件判断 if、if-else、if-elif-else
①if语句
if 条件:
满足条件执行的语句
②if-else
if 条件1：
满足条件1执行的语句
else：
不满足条件1执行的语句
③if-elif-else
if 条件1：
满足条件1执行的语句
elif 条件2：
满足条件2执行的语句
else：
不满足上述条件执行的语句
另外2种变种写法如下（减少代码行数，同样也降低了代码可读性）：
输入分数，60以下不及格，60到79为及格，80到100为优秀，100以上为分数错误
a = int(input("please input score: "))
b = "wrong" if a>100 else("good" if a>=80 else ("ok" if a>=60 else "bad"))
print(b)
c = int(input("please input score: "))
if c>100: print("wrong")
elif c>=80: print("good")
elif c>=60:print("ok")
else: print("bad")
14.while循环
while 条件：
满足条件执行的循环体
注意：while循环是每次循环结束后，会再次检查条件是否满足；
使用循环时，要对循环条件加以控制，否则会进入死循环。
break：终止循环（当前层次的循环）
continue：跳出本次循环（continue后面的代码是不执行的），开始下次循环
注：break、continue只用在while、for循环中
# 比如忏悔场景，continue是到10次时标记一下，break是到10次时停止
times = 0
while times < 20:
times += 1
if times == 10:
print("已经忏悔10次了")
continue
# break
print("第%d次忏悔"%times)
15.for循环语句
for 变量 in 集合：
集合内依次取值，执行满足条件的循环体
for循环的次数由集合的个数决定
16.range函数
range(m,n,t) 表示连续的整数范围，m起始值，n-1结束值，t步长，步长为1时可省略
range(1,5) →：1,2,3,4
range(1,5,2) →：1,3
range(5) →：0,1,2,3,4
17.嵌套循环（99乘法表）
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%d"%(j,i,i*j),end = " ")
print()
18.集合 set
集合（set）是一个无序、不重复元素的序列，不支持索引取值。
可以使用大括号 { } 或者 set() 函数创建集合。
注意：创建空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
set1 = set() # 创建空集合
set2 = {5,7,'tom',6,9,128,64} # 创建非空集合
set2.add('杰瑞') # 添加元素
print(set2)
set2.remove('tom') # 删除元素
print(set2)
print(len(set2)) # 统计元素个数
print(6 in set2) # 判断元素是否在集合中
set3 = {11,5,11,6} # 自动过滤重复的值
print(set3) →：{11, 5, 6}
列表去重：
list1 = [1,5,2,1,4,6,2,8,6,9,8,2,3]
set1 = set(list1)
list2 = list(set1)
print(list2)
19.字典 dict
字典由多个键值对组成，键必须唯一，值可以重复
dict2 = {'name':'tom','age':20}
name是键，即key，tom是值，即value
dict1 = {} # 定义空字典
print(type(dict1))
dict2 = {'name':'tom','age':20} # 定义非空字典
print(dict2)
print(dict2) # 访问字典
print(dict2['name']) # 获取指定键的值
print(dict2.get('age')) # 使用get方法获取指定键的值
# 两种获取的区别：如果不小心输错键，中括号会报错，get会直接返回None。
dict2['sex'] = '男' # 新增字典的键值对
print(dict2)
del dict2['age'] # 删除字典的键值对
print(dict2)
dict2['name'] = '杰瑞' # 修改字典的值
print(dict2)
print(len(dict2)) # 统计字典的键值对个数
print('name' in dict2) # 判断键是否在字典中，不能判断值
# 字典和列表的嵌套访问（掌握）
list1 = [20,'橘子',{'name':'tom','age':20},666]
print(list1[2]) # 打印出列表中的字典
print(list1[2]['name']) # 获取字典中name的值
print(list1[2].get('age'))
# 多层嵌套（列表套字典）
list1 = [[20,'橘子'],20,[{'name':'tom','age':20},5],666]
print(list1[2][0]['name']) →：tom
print(list1[2][0].get('age')) →：20
# 多层嵌套（字典套列表，列表再套字典）
list1 ={'stu':[[20,'橘子'],20,[{'name':'tom','age':20},5]],'num':999}
print(list1['stu'][0][1]) →：橘子
print(list1['stu'][2][0].get('age')) →：20
补充内容（了解即可）：
print(dict2.items()) # 获取键值对
for i in dict2.items(): # 使用for循环遍历键值对
print(i)
for i,j in dict2.items(): # 使用for循环分别遍历键和值
print(i,j)
print(j)
print(dict2.keys()) # 获取所有键
print(dict2.values()) # 获取所有值
print(dir(变量)) # 查看变量的内置方法，变量可以是字典、集合等等
第二部分---------------------------------------------------------------
20.函数
def 函数名(参):
函数体
def stu(name):
print('我叫'+name)
stu('tom') # 调用函数
def stu(name):
return '我叫'+name
print(stu('lily')) # 调用函数
1.无参函数
def plus():
return a+b
a,b = 1,2
print(plus())
2.有参函数
def def1(name):
return '我的名字是%s'%name
name = 'tom'
print(def1(name)) →：tom
print(def1('lily')) →：lily
3.关键字参数(即使参数颠倒，也不影响结果，如stu3)
def stu1(name,home):
return '我叫%s,来自%s'%(name,home)
print(stu1('tom','南京')) →：我叫tom，来自南京
def stu2(name,home):
return '我叫%s,来自%s'%(name,home)
print(stu2('南京','tom')) →：我叫南京，来自tom
#即使参数颠倒，也不影响结果，如stu3
def stu3(name,home):
return '我叫%s,来自%s'%(name,home)
print(stu3(home='南京',name='tom')) →：我叫tom，来自南京
4.默认参数
def def3(name = 'lily',age = 25):
return '我是%s，今年%d岁'%(name,age)
name1 = 'tom'
age1 = 666
print(def3()) →：我是lily，今年25岁
print(def3(name1)) →：我是tom，今年25岁
print(def3(name1,age1)) →：我是tom，今年666岁
# print(def3(name,age)) # 这里不知道name，age是什么，所以会报错
补：pass是占位符，当函数体不知道写什么时，可以用pass占位，保证程序不报错
21.模块
模块可以理解为是一个包含了函数和变量的py文件，在程序中引入某个模块，
就可以使用其中的函数和变量。
语法： import 模块名
from 模块名 import 方法
from time import * # 表示导入time模块下所有方法
1. os模块
# 获取当前的工作目录
import os
print(os.path.abspath('.')) # 打印当前文件所在的路径
print(os.getcwd()) # 打印当前文件所在的路径
# 获取当前文件完整路径
print(os.path.abspath(__file__)) # 打印当前文件完整路径
# 获取上一级路径：os.path.dirname(path)
print(os.path.dirname(r'C:\test\test1.py')) # 打印当前文件的上一级路径
print(os.path.dirname(os.getcwd())) # 打印当前文件所在的路径上一级路径
os.path.dirname(os.path.abspath(__file__)) # 模块文件所在路径（常用）
# 将a，b两个路径连接起来：os.path.join(a,b)
cur = os.getcwd()
new = os.path.join(cur,'test2.py')
print(new)
# 注意要连接的两个路径，前面路径的末尾、后面路径的开头不能有\
new2 = os.path.join(r'C:\test',r'test2\test3.py')
print(new2)
2.time模块
import time
time.sleep(2) # sleep()休眠时间，单位是秒
print('打印中……')
from time import sleep,ctime
sleep(2)
print(ctime()) # ctime() 打印当前时间
补充（了解）：
①
from time import *
print(strftime('%F')) →：2021-11-03
print(strftime('%X')) →：10:02:38
print(strftime('%Y-%m-%d')) →：2021-11-03
print(strftime('%H:%M:%S')) →：10:02:38
②
from datetime import date,timedelta
print(date.today()) →：2021-11-03
print(date.today() + timedelta(-3)) →：2021-10-31
endtime = str(date.today()) + ' 12:12:12'
print(endtime) →：2021-11-03 12:12:12
3.random 随机数
from random import randint,choice
num = randint(1,5) # 从1到5之间取随机整数
print(num)
list1 = [666,'橘子','tom','hello']
print(choice(list1)) # 从列表随机获取元素
4.自定义模块
calc1、calc2、clac3、calc4的内容都一样的：
def jia():
return a+b
def jian():
return a-b
def cheng():
return a*b
def chu():
return a/b
a,b = 1,2
1.脚本文件与调用模块在同一文件夹下
from calc1 import jia
print(jia())
注：脚本文件test.py跟调用文件calc1.py都在同一个文件夹下
2.调用文件在脚本文件的子文件夹下
from haha.calc2 import jia,jian
print(jian())
注：脚本文件是test\lianxi.py，调用文件是test\haha\calc2.py
3.调用模块在脚本文件的父级文件夹下，可以使用相对路径
import sys
sys.path.append('../') #导入临时路径
from calc import *
print(cheng())
注：脚本文件是liu\test\lianxi.py，调用文件是liu\calc.py
4.调用文件跟脚本文件离得太远，用绝对路径
import sys
sys.path.append(r'D:\test')
from calc import *
print(chu())
注：脚本文件是C:\liu\lianxi.py，调用文件是D:\test\calc.py
22.异常处理
try:
检测范围
except:
出现异常后的处理
23.类
类：比如一辆汽车的设计图，类名首字母一般要大写
类的属性：类里面的变量
类的方法：类里面的函数
类的实例化：按图纸做出来的实例，即对象
class 类名:
类的属性
类的方法
所有方法的第一个参数必须是self，但是使用时，无需传参！
class Car(): # 类名首字母大写
color = '白色' # 定义属性
brand = '宾利'
def desc(self): # 定义方法
return '车的颜色是'+ self.color + '，品牌是'+ self.brand
c = Car() # 类的实例化，也叫对象
print(c.brand) # 访问类的属性
print(c.desc()) # 访问类的方法
对象 = 属性 + 方法
比如兔子是对象，有静态特征、动态行为
属性：三瓣嘴、长耳朵、红眼睛
方法：跑、跳、吃东西
传参
class Geli(): # 类名首字母大写
brand = "格力"
def phone(self,brand,color="白色"):
return "我现在是%s，但原来是%s，颜色是%s"%(brand,self.brand,color)
g = Geli() # 类的实例化，即对象
# brand传参，color使用默认值
print(g.phone("大松")) # 我现在是大松，但原来是格力，颜色是白色
# brand传参，color也传参
print(g.phone("大松","黑色")) # 我现在是大松，但原来是格力，颜色是黑色
继承
class Xiaomi():
brand = '小米'
color = '白色'
camera = '无敌'
def xm(self):
return '颜色是'+ self.color
class Redmi(Xiaomi):
brand = '红米'
color = '红色' # 重写
def rm(self):
return '品牌是'+ self.brand + self.camera
mi = Redmi()
print(mi.rm()) # →：品牌是红米无敌
print(mi.color) # →：红色
print(mi.camera) # 继承父类，→：无敌
print(mi.xm()) # →：颜色是红色
面向对象的三个特点：
封装：将具有同一特点的属性、方法，写入一个类里面
继承：子类继承父类的所有特征（属性、方法）
多态：通过重写来实现
注：定义类若无继承父类时，类名后面的括号也可省略，根据个人习惯来
24. MySQL数据库的操作
1.安装
pip install mysql-connector
pip install mysql-connector -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple mysql-connector
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 库名==1.3.0
在线安装或使用国内源安装
验证安装是否成功：import mysql.connector
安装成功后，在python/lib/site-package下面会多出mysql文件夹
2.连接数据库
# import mysql.connector
# mydb = mysql.connector.connect()
from mysql.connector import connect #导包
mydb = connect(
host = '211.149.163.145',
port = '3306', # 默认端口可以省略
user = 'test',
password = 'test123', # password也可以写成passwd
database = 'test') # database也可以写成db
mycursor = mydb.cursor() # 建立数据库的操作集（游标）
注：每一步增删改查之前，必须要连接数据库和建立操作集
3.查询
sql = "select * from users;"
mycursor.execute(sql) # 执行sql
res = mycursor.fetchall() # 获取所有记录
print(res) # 以列表形式打印结果，或使用下面的for循环逐条打印
for i in res:
print(i)
4.修改
sql = "update users set passwd = 'haha' where username = '彭俊杰';"
mycursor.execute(sql)
mydb.commit()
print('修改的数据条数为：' + mycursor.rowcount) # 打印执行结果
注：修改数据需要提交事务，获取“几条数据受到影响用mycursor.rowcount”结果
5.删除
sql = "delete from users where username = 'lhj';"
mycursor.execute(sql)
mydb.commit()
print('删除的数据条数为：' + mycursor.rowcount)
注：修改数据需要提交事务，获取“几条数据受到影响用mycursor.rowcount”结果
6.新增
sql = "insert into users values(%s,%s);"
val = ('juzi','juzi')
mycursor.execute(sql,val)
mydb.commit()
print('插入的数据条数为：' + mycursor.rowcount)
7.新增多条数据，适用于MySQL（了解）
sql2 = "insert into users values(%s,%s);"
values2 = [('随便2','20'),('随便3','20'),('随便4','20')]
n = 0
for values in values2:
mycursor.execute(sql2,values)
mydb.commit()
n = n + mycursor.rowcount
print('新增了',n,'条数据')
8.关闭数据库连接（了解）
mydb.close()
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
