python基础教程目录，从入门到上手的

因为清晰易读的风格，广泛的适用性，Python已经成为最受欢迎的编程语言之一。在TIOBE 排行榜中位居第四，是名副其实的人工智能第一语言。
风靡的另一个原因是，Python有非常多的第三方库。比如用于WEB开发的Django/Flask，用于科学计算的 Numpy/Scipy，用于机器学习的 Scikit-Learn，用于运维的 Supervisor/Fabric，用于网络爬虫的 BeautifulSoup/Scrapy……这些你都可以轻松调用实现，不用再造轮子。

一、Python入门、环境搭建、变量、数据类型

Python的简介
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。
Python的特点
1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单
2.易于阅读：Python代码定义的更清晰。
3.易于维护：Python的成功在于它的源代码是相当容易维护的。
4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
8.数据库：Python提供所有主要的商业数据库的接口。
9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。
10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。
环境搭建
Python的环境搭建其实是跟我们java的环境搭建是一样的，java需要下载jdk，我们Python同样需要下载“jdk”跟jdk是一样的不过它不叫jdk，就叫Python，小编这里安装的是3.7.4版本的
变量
这里跟java的区别就是没有了类型

变量名：必须是大小写英文、数字和_组成，且不能用数字开头

规范：变量名 = 变量值
比如：
#字符串既可以是单引号也可以是双引号
name = ‘Snail’
age = 22

数据类型
数据类型，我们来跟java做一个对比。我们java有8个，Python也是8个。但是我们的Python有一些事跟java不一样的，比如：list列表，tuple元组，dict字典，和set集合。在java中也有set集合这个Python其实是跟它一样的。字典其实跟java的Map也差不多

java数据类型：
byte short int long 
double float
char 
boolean

Python数据类型:

数值：int float
字符串：str
布尔类型：bool
列表list
tuple元组：类似Java中的数组
集合set
字典dict:类似java中的Map

list列表
List运算


注意：list方法使用规则：列表名 . 方法()比如：name.append(“元素”)

tuple元组
set集合
Set集合就和Java中的Set集合是一样的概念，存放的数据是无序的，并且不能添加重复的元素

创建set集合，使用{},多个值之间用，隔开
语法：
集合名={值1，值2}

set方法

dict字典（Map）
Dictionary字典，就类似java中的Map集合，以“键值对”的形式存放数据，key不能重复
语法格式：

字典名={key1:value1，key2:value2} 获取值：
①.语法：字典名[“key”]，比如：person[“name”]，如果key不存在则会报错 ②.语法：字典名.get(“key”)，比如
person.get(“name”),如果key不存在，不会报错，可以设置第二个参数为默认值 修改：
语法：字典名[key]=value，如果key存在则修改，如果不存在则创建一个新的key和value eg：
person[“name”]=“张三丰” 删除： 语法：del 字典名[key] eg： del person[“name”]

dictionary方法

代码测试：

# 单行注释：#  Ctrl+/
"""
这是多行注释：3对双引号
"""
'''
这是多行注释：3对单引号
'''
print("hello world")
# 定义变量
# 语法格式：  变量名 = 变量值
name = "张三"
age = 22
salary = 2222.25
number = 22
print(name)
# 注意：字符串拼接符+ 只能用在字符串类型
print("我是"+name)
# 把int转成str类型
print("我今年"+str(age)+"岁")
# , 格式化工具 特点：有空格
print("我是", age)

"""
%s ：用在字符串类型
%d ：用在整数，默认是原样输出。设置位数不足时，用零补全，格式：%0nd(设置为位数)
%f ：用在浮点类型，默认小数点后保留6位，设置小数点后保留的个数，格式%.nf(n则为保留的位数)
"""
print("我的名字是%s" % name)
print("我的年龄是%d岁" % age)
print("我的日工资是%.1f元" % salary)
print("我的学号是%03d号" % number)

print("我的名字是%s,我的年龄是%d岁,我的日工资是%.1f元" % (name, age, salary))
# 全部类型都用%s
print("我的名字是%s,我的年龄是%s岁,我的日工资是%s元" % (name, age, salary))

# 格式化符号f
print(f"我的名字是{name},我的年龄是{age}岁,我的日工资是{salary}元")

# 转义字符
print("人生\t苦短", end = "\"")
print("我用Python")

"""
java数据类型：
byte short int long 
double float
char 
boolean

Python数据类型:
数值：int float
字符串：str
布尔类型：bool
列表list
tuple元组：类似Java中的数组
集合set
字典dict:类似java中的Map
"""
# bool
isMan = True
print(isMan)

"""
list列表：
定义格式：[]
CRUD
"""

# 定义list列表
hobbies = ["吃饭", "睡觉", "打豆豆", "敲代码", "打篮球", "泡妞"]
# 查询所有
print(hobbies)
# 查询单个
print(hobbies[2])
# 查询某些，使用切片 语法格式：列表名[起始位置:结束位置:步长]
print(hobbies[0:6:3])
# 从倒数位拿数据
print(hobbies[-1])

# 倒数获取数据
print(hobbies[::-2])
# 添加或者替换
hobbies[1:2] = ["rap", "唱歌"]
print(hobbies)

# 删除单个
# 语法格式：  del 列表名[下标]
# del hobbies[0]
# print(hobbies)
# 删除多个
# 语法格式：  del 列表名[切片]
del hobbies[::2]
print(hobbies)

# list运算：  +  *  in not in
list1 = [1, 2, 3]
list2 = [3, 5, 6]
print(list1+list2)
print(list1*5)
print(2 in list1)
print(2 not in list1)

# 函数
print(len(list1))
print(min(list1))
print(max(list1))

# list方法
# 追加
list1.append(4)
list1.extend([10, 8])
list1.insert(0, 20)

# 删除
list1.pop(1)
list1.remove(2)
# list1.clear()
print(list1)

print(list1.index(20))
list1.reverse()
print(list1)

list1.sort(reverse=True)
print(list1)


"""
元组tuple
定义格式：()
不能增删改，只能查
"""
gender = ("男", "女", "人妖", "ji", "ya", "e")
print(gender)
# 添加：不可以
# gender[0:0] = ["不晓得"]
# 修改
# gender[0] = "Man"
# print(gender)

a, b, c, d, e, f = gender
a, *b = gender
print(b)

m = 1
n = 2
print(n, m)
m, n = n, m
print(n, m)

"""
集合：set
定义格式：{}
"""
provinces = {"湖南省", "湖北省", "山西省", "山东省"}
print(provinces)
# 添加：不能使用和下标有关的
# provinces[0:0] = ["长沙省"]

"""
字典:Map
语法：{"key"："value","key"："value"}
"""

person = {"name": "老王", "age": 37}
print(person)

# 遍历dict
# 01
for key in person.keys():
    print(key, person.get(key))

# 02
for value in person.values():
    print(value)

# 03
for k, v in person.items():
    print(k, v)

# 检测变量的数据类型
print(type(name))
print(type(age))
print(type(salary))
print(type(person))

num = input("请输入您的银行卡密码：")
print(num)

总结：推荐python学习解答学习扣扣群:数字778数字747数字511。欢迎有想法学习的python的伙伴加入，评论，每天有免费的直播课，

二、Python运算符、条件结构、循环结构

一、Python变量类型
类型
数值型、字符串、元组、列表、字典等
例：c/c++、java是强类型的编程语言，一个变量在使用前确定类型，在程序期间，变量的类型是不能改变的；
脚本语言：shell、python、perl、javaScript弱类型；

Python支持三种不同的数字类型

#有符号整数
int
#浮点实数值
float
#例 
#16进制---0X 0x
#8进制---0o  0O
#2进制---0b  0B
#二进制：bin() 八进制:oct() 十六进制：hex()
#复数
complex
#注意：复数由一对有序组成，
#通过 x + yj 来表示实浮点数，
#其中 x 和 y 是实数并且 j 是虚数单位

在Python3所有整数表示为长整型。因此，没有单独为long的整数类型。

#例
c1=bin(8)
print(c1)#0b1000
c2=oct(8)
print(c2)#0o10
c3=hex(8)
print(c3)#0x10

字符串

#字符串变量
s="abc"
s='abc'

将多个变量分配给不同的变量

x,y=6,8
print(x,y)

二、python支持运算
2.1算术运算符

#幂运算
x=8**3#8*8*8
#y得到float类型有小数点值
y=7/3

#取整相除
y2=7//3  #y2返回2

2.2 比较(关系)运算符

x=8==8
print(x)#True
y=False
print(y)

2.3 赋值运算符

x=3
x+=5
print(x)
#//= 地板除
x//=3
print(x)
y=5.2789
y=y//2.954#返回1.0
print(y)

2.4 逻辑运算符

#and  or   not
#input函数得到用户输入数据
year=int(input("请输入年份"))
#通过int()函数将参数转换成整数
print(int(3.14))
if(year%400==0 or (year%4==0 and year%100!=0)):
    print("是一个闰年...")

#例如：
    #if条件表达式或数值
    if(not 0):
        print("abc")
    print("over")   

2.5位运算符

# >  &  | ^ !  ~  <<  >>

2.6 运算符成员
in ,not in
某元素是否在序列中，其中字符串就是序列

 #例
 s="掌声"
    y="声"
    #s是字符串，in表示判断y是否在s中存在
    c=y in s
    print(c)#True

2.7 标识运算符
is如果操作符两侧是相同的对象，计算结果为true，否则结果为 false
is not 如果操作符两侧的变量是相同的对象，计算结果为false，否则 true

三、python流程控制结构
3.1 python 条件结构

#语法:
  if():
#    多条语句体
#注意：
#if结构的语句体可以多条,使用统一位置缩进控制语句体；
#例：
     if(条件):
        语句体....
  if()...else
#  语法：
  if():
     多条语句体
  else:
     多条语句体
  if():...elif():...else:
  语法：
  if():
     多条语句体
  elif():
     多条语句体
  elif():
     多条语句体
  else:

 多条语句体

3.2循环
3.2.1 while循环

i=0#A循环变量的初始化
        while(i<5):#B循环条件
            print(i)
            i+=1#C循环体内改变循环变量值

3.2.2 break，continue while…else

# else表示当while条件不成立，执行else部分
 #例：
  i=1   
        while(i<4):
            print(i)
            i+=1
            if(i==3):break
        else:
            print("循环结束...")
            print("ok")

        print("over...")
        结果：
        1
        2
        over...

3.2.3 for…in循环

for 迭代变量 in 集合:
    语句
    ...
[else:
    语句
    ...]
#注意：
   #和for循环配合使用range函数
    range(stop) 
    range(start, stop[, step])

for i in range(10,100,20):
            print(i)

#练习 for..in循环实现斐波那契数列 
        1，1，2，3，5，8...
        one=1
        two=2
        for month in range(3,14):
            three=one+two
            print(three)
            #数值辗转
            one=two
            two=three
#函数
    def fn(n):
        if(n<=1):
            return n;
        else:
            return (f(n-1)+f(n-2))
    for i in range(20):
        print(f(i))

#例：
 i=1
        while(i<11):
            i = i + 1
            if(i%2!=0):
                continue
            print(i)

#例：九九乘法表
    i=1
    while(i<10):
        j=9
        while(j>=1):
            #输出格式
            s="%d*%d=%d"%(i,j,i*j)
            print(s,sep="\t",end="\t")
            j-=1
        print()
        i=i+1
# for 循环
for i in range(1,10):
    for j in range(1,i+1):
        s="%d*%d=%2d"%(i,j,i*j)
        print(s,sep="\t",end="\t")
    print()

三、Python函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression

后续学习，详细点击Python函数

四、做一次综合练习,做一个控制台的员工管理

直接上代码

"""
需求：员工管理系统
功能:
1.添加员工信息
2.删除员工信息
3.修改员工信息
4.查看单个员工信息
5.查看所有员工信息
6.退出

技术：函数、数据类型(字典列表)、循环、条件语句
"""
emps = []   # [{},{}]


def chocieFunc():
    """选择功能列表"""
    print("*" * 30)
    print("1.添加员工信息")
    print("2.删除员工信息")
    print("3.修改员工信息")
    print("4.查看单个员工信息")
    print("5.查看所有员工信息")
    print("6.退出")
    print("*" * 30)


def addEmp():
    """添加员工信息"""
    id = input("请输入要添加的员工编号：")
    name = input("请输入要添加的员工姓名：")
    gender = input("请输入要添加的员工性别：")
    age = input("请输入要添加的员工年龄：")
    emp = {"id": id, "name": name, "gender": gender, "age": age}
    emps.append(emp)
    print("添加OK！")


def delEmp():
    """删除员工信息"""
    id = input("请输入要删除的员工编号：")
    for emp in emps:
        if emp.get("id") == id:
            # 将emp删除,从emps
            emps.remove(emp)
            print("删除OK！")
            break
    else:
        print("请输入正确的员工编号")


def updateEmp():
    """修改员工信息"""
    id = input("请输入要修改的员工编号：")
    for emp in emps:
        if emp["id"] == id:
            # 特别注意
            emp["name"] = input("请输入要修改后的员工姓名：")
            emp["gender"] = input("请输入要修改后的员工性别：")
            emp["age"] = input("请输入要修改后的员工年龄：")
            # emp = {"id": id, "name": name, "gender": gender, "age": age}
            # 先删除原有的emp,在追加新的emp【不推荐】
            print("修改成功！！！")
            break
    else:
        print("查无此人！！！")


def getEmpById():
    """查看单个员工信息"""
    id = input("请输入要查询的员工编号：")
    for emp in emps:
        if emp["id"] == id:
            print("编号\t姓名\t性别\t年龄")
            print(f"{emp['id']}\t{emp['name']}\t{emp['gender']}\t{emp['age']}")
            break
    else:
        print("查无此人！！！")


def getAllEmps():
    """查看所有员工信息"""
    print("编号\t姓名\t性别\t年龄")
    for emp in emps:
        print(f"{emp['id']}\t{emp['name']}\t{emp['gender']}\t{emp['age']}")
    else:
        print(f"共查询到{len(emps)}条数据")


print("******欢迎使用员工管理系统******")
while True:
    chocieFunc()
    num = int(input("请输入指令:"))
    if num == 1:
        addEmp()
    elif num == 2:
        delEmp()
    elif num == 3:
        updateEmp()
    elif num == 4:
        getEmpById()
    elif num == 5:
        getAllEmps()
    elif num == 6:
        print("欢迎下次再来！！！")
        break
    else:
        print("请输入正确的指令")

五、面向对象(封装、继承、多态)

封装是指隐藏类的实现细节，方便其他人的调用。

封装的目的：
让使用者可以通过间接调用方法或属性操作对象。
所以Python使用封装时，必会使用私有属性和方法。
私有属性和方法：
以‘__’双下划线开头，不以双下滑线结尾的表示符为私有成员，
私有成员只能使用该类的方法，来进行访问和修改
1. 以__开头的属性为私有属性 如__vol
2. 以__开头的方法为私有方法 如__vol()
注：python封装是假的封装（模拟的封装）
比如通过dir查看属性就可以发现，其实私有属性被变成了_class__xx,所以才无法访问
多态 polymocphic
字面意思：‘多种状态’
多态是指在有继承/派生关系的类中，调用基类对象的方法，实际能调用子类的覆盖方法的现象叫多态
状态：
静态（编译时状态）
动态（运行时状态）
说明：
1，多态调用的方法与对象相关，不与类型相关
2，Python全部对象都只有“运行时状态（动态）”
没有C++语言里的编译时状态(静态)
继承 inheritance
继承是从已有的类中派生出新的类，新类具有原类的数据属性和行为，并
能拓展新的行为
继承的目的：
延续旧类的功能
单继承
语法：
class 类名（基类名）：
语句块
说明：
单继承是指派生类由一个基类衍生出来的新类
多继承 multiple inheritance
多继承是指一个子类继承自两个或两个以上的基类
语法：
class 类名（基类名1，基类名2，…）
说明：
一个子类同时继承自多个父亲，父类的方法可以同时被继承下来
如果两个父亲中有同名的方法，而在子类中又没有覆盖此方法时，调用
结果难以确定
多继承的问题（缺陷）
标识符冲突问题
（一般不推荐使用多继承）

六、模块、包、文件、异常、高阶函数

模块
ython 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
“”"

导入模块
方式一 ：import 模块名
方式二 ：from 模块名 import 功能
方式三： from 模块名 import *
"""

# import Sinal

# import Sinal as a
# # 实列化模块中的类  加模块
# person = a.Person()
#
# person.eat()
# person.sleep("楠楠")
#
# a.playDD()
# print(a.age)


# 方式二 ：from 模块名 import 功能
# from Sinal import Person
# from Sinal import playDD
# from Sinal import age
#
# person = Person()
# person.sleep("小花")
#
# playDD()
# print(age)

# 方式三： from 模块名 import *
from myPackage.Sinal import *
person = Person()
person.sleep("小草")

包
1、什么是包？
官网解释
Packages are a way of structuring Python’s module namespace by using “dotted module names”
包是一种通过使用‘.模块名’来组织python模块名称空间的方式。
具体的：包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来
需要强调的是：
在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错
创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块
2、为何要使用包
包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来 随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性
3、注意事项
1.关于包相关的导入语句也分为import和from … import …两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
2、import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件
3、包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

"""
包

方式1：import 包名模块名
方式2: from 包名.模块名 import 功能
方式3：from 模块名 import 功能
"""

# 方式1：import 包名模块名
# import myPackage.Sinal
#
# person = myPackage.Sinal.Person()
# person.sleep(23)
#
# myPackage.Sinal.playDD()


# 方式二
# from myPackage.Sinal import Person
# person = Person()
# person.sleep("nn")

# 方式3
from myPackage.Sinal import *
person = Sinal.Person()
person.sleep("nn")

文件

"""
文件
a:追加  append 没有文件的时候会报错
r:读取 read 没有文件的时候会报错
w:写 writer 在文件没有的时候自动创建 
"""

f = open("readme.txt", "r", encoding="UTF-8")
# f.write("好好学习，天天向上")


# 读文件
# content = f.read(2)
# content = f.readline()
content = f.readlines()
print(content[1])

# 复制
try:
   f = open("C:/test.py", "r")
   content = f.read()
   print(content)

   a = open("D:/test.py", "w")
   a.write(content + "这个成功了")
   a = open("D:/test.py", "r")
   read = a.read()
   print(read)

except Exception:
    print("不好意思了,失败了呢")
else:
    print("好棒，成功了")
———————————

异常
什么是异常
异常是一个事件，该会在程序执行过程中发生，影响了程序正常执行。一般情况下，在Python无法正常处理程序时就会发生一异常。异常是Python对象，表示一个错误。当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。
常见异常类型
异常名称 描述
FileNotFoundError 找不到指定文件的异常
NameError 未声明/初始化对象（没有属性）
BaseExcption 所有异常的基类

异常处理语句
try…except
try…except…finally
raise

"""
异常

语法格式：
try:
    可能会出现的异常代码
except 异常类型1，异常类型2 | Exception:
    出现异常，解决异常的办法
else:正常的代码
finally:
    无论有没有异常都会执行
"""

# 自定义异常  判断密码长度并能小于6位大于8位

# try:
#     a = 6/0
# except ZeroDivisionError:
#     print("不能这样除呢")
# else:
#     print(a)
# finally:
#     print("结束了，拜拜")

class MyException(Exception):

    def __init__(self, length, minLength):
        self.length = length
        self.minLength = minLength

    def __str__(self):
        return f"输入的长度为{self.length},要求长度最少{self.minLength}位"


# try:
#     a = 6/0
# except ZeroDivisionError:
#     print("除数不能为0")
# else:
#     print(f"a={a}")
# finally:
#     print("运算结束")

try:
    pwd = input("请输入密码：")
    if len(pwd) < 6:
        raise MyException(len(pwd), 6)
except MyException as result:
    print(result)
else:
    print(pwd)

高阶函数
什么是高阶函数？
　　高阶函数：一个函数可以作为参数传给另外一个函数，或者一个函数的返回值为另外一个函数（若返回值为该函数本身，则为递归），满足其一则为高阶函数。

　　"""
高阶函数
map()
reduce()
filter()
"""

import functools

# 内置函数
# print(abs(-5))
# print(round(12.99, 1))

# 高阶函数：
# map()
list1 = [1, 2, 3, 4, 5]

# def two(x):
#     return x ** 2

# result = map(two, list1)
# print(list(result))

# reduce()

# def add(x, y):
#     return x+y
#
#
# print(functools.reduce(add, list1))


# filter
def ou(x):
    return x % 2 == 0

result = filter(ou, list1)
print(list(result))

总结：Python.模块、包、文件、异常、高阶函数学习介绍到这里了，给邀请喜欢学习的伙伴加入python解答学习扣扣群;778数字747数字511 ，一起学习，一起进步

七、Python标准库之字符串处理库、文件及目录操作、时间日期

1.文件及目录操作
os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：具体操作点击“文件及目录操作”

2.字符串处理库
字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Python Runoob"

Python 访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号来截取字符串，如下实例
实例(Python 2.0+)

#!/usr/bin/python
 
var1 = 'Hello World!'
var2 = "Python Runoob"
 
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

以上实例执行结果：

var1[0]:  H
var2[1:5]:  ytho

Python 字符串连接
我们可以对字符串进行截取并与其他字符串进行连接，如下实例：
实例(Python 2.0+)

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
var1 = 'Hello World!'

print "输出 :

• ", var1[:6] + ‘Runoob!’
  Python 转义字符
  在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符 ，想需要学习点击：继续学习完整读完这一节

八、Python数据库编程

数据库的基本操作
创建数据库：

CREATE DATABASE test;

GRANT ALL ON test.* to user(s);

第一行创建了一个名为“test”的数据库，假设你是数据库的管理员，第二行语句可以为指定用户（或所有用户）提升权限

使用数据库

USE test;

如果你已经登录一个数据库系统，但是还没有选择你希望使用的数据库，这条简单的语句可以让你指定一个数据库，用来执行数据库操作。

删除数据库

DROP DATABASE test;

这条简单的语句可以从数据库中移除所有表和数据，并将其从系统中删除。

创建表

CREATE TABLE users (login VARCHAR(8), userid INT, projid INT);

这条语句创建一个新表，其中包含字符串列login,以及两个整型列：userid和projid。

删除表

DROP TABLE users;

这条简单的语句可以删除数据库中的一个表，并清空其中的所有数据。

插入行

INSERT INTO users VALUES(‘leanna’,2111,1);

可以使用INSERT语句向数据库中插入一个新行。需要指定表名以及其中每列的值。对于本例而言，字符串“leanna”对应于login参数，而2111和1分别对应于userid和projid。

更新行

UPDATE users SET projid=4 WHERE projid=2;

UPDATE users SET projid=1 WHERE userid=311;

为了修改表中已存在的行，需要使用UPDATE语句。使用SET来确定要修改的列，并提供条件来确定修改的行。在第一个例子中，所有“projid”为2的用户需要改为4。而在第二个例子中，将指定用户（这里是userid为311的用户）移到编号为#1的项目组中。

删除行

DELETE FROM users WHERE projid=%d;

DELETE FROM users;

为了删除表中的行，需要使用DELETE FROM 命令，指定准备删除的行的表名以及可选的条件。如果没有这个条件，就会像第二个例子样，把所有行都删除了。

以上就是数据库的一些基本的操作，从上我们可以看出：

创建数据库（create）和删除数据库（drop），创建表和删除表也一样。

修改表中已存在的行叫做更新（update）和往数据库里添加新行叫做插入（insert）

而移出表中已存在的行叫做删除（delete）。

这些动作通常称为数据库命令或操作。使用可选的条件请求数据库中的行称为询查（query）。

函数属性&对象方法

connect()函数属性
user                     用户名
password             　　密码
host                     主机名
database             　　数据库名　　MySQLdb数据库使用的是db
dsn                      数据源名
connect()函数通过 Connection 对象访问数据库。兼容模块必须实现 connect()函数，该函数创建并返回一个 Connection 对象。

应用与数据库之间进行通信需要建立数据库连接。它是最基本的机制，只有通过数据库连接才能把命令传递到服务器，并得到返回的结果。当一个连接（或一个连接池）建立后，可以创建一个游标，向数据库发送请求，然后从数据库中接收回应。

Connection 对象方法
Connection 对象不需要包含任何数据属性

close()                        　　　　　　 　关闭数据库连接
commit()                        　　　　　　  提交当前事务
rollback()                        　　　　　　取消当前事务
cursor()                        　　　　　　  使用该连接创建（并返回）一个游标或类游标的对象
errorhandler(cxn,cur,errcls,errval)          作为给定连接的游标的处理程序                           
 

当使用 close()时，这个连接将不能再使用，否则会进入到异常处理中。

如果数据库不支持事务处理，或启用了自动提交功能，commit()方法都将无法使用。如果你愿意，可以实现单独的方法用来启动或关闭自动提交功能。

处理的数据库而言，只需要在方法中实现“pass”即可。

和 commit()相似，rollback()方法也只有在支持事务处理的数据库中才有用。发生异常之后，rollback()会将数据库的状态恢复到事务处理开始时。

如果 RDBMS 不支持游标，那么 cursor()仍然会返回一个尽可能模仿真实游标的对象。这是最基本的要求。每个适配器开发者都可以为他的接口或数据库专门添加特殊属性。

当你完成数据库连接并关闭游标时，需要对所有操作执行 commit()，并对你的连接执行close()。

Cursor 对象

arraysize                    　　　　　　使用fetchmany方法时，一次取出的结果行数，默认为1
connection                  　　　　　　 创建此游标的链接（可选）
description                  　　　　　　返回游标活动状态（7选项元组）:（name,type_code,display_size,internal_size,precision,scale,null_ok）
lastrowid                    　　　　　　上次修改的行ID（可选：如果不支持行ID，则返回None）
rowcount                    　　　　　　 上次execute*()方法处理或影响的行数
callproc(func[,args])      　　　　　　  调用储存过程
close()                        　　　　  关闭游标
execute(op[,args])        　　　　　　　 执行数据库查询或命令
executemany(op,args)    　　　　　　　　 类似execute()和map()的结合，为给定的所有参数准备执行的数据库查询或命令
fetchone()                    　　　　   获取查询结果的下一行
fetchmany([size=cursor.arraysize])      获取查询结果的下面size行
fetchall()                       　　   获取查询结果的所有（剩余）行
__iter__()                      　　　  为游标创建迭代器对象（可选，参考next()）
messages                       　　　　 游标执行后从数据库中获取的消息列表（元组结合，可选）
next()                           　　   被迭代器用于获取查询结果的下一行（可选，类似fetchone()，参考__iter__()）
nextset()                        　　   移动到下一个结果集合（如果支持）
rownumber                      　　    当前结果集中游标的索引（以行为单位，从0开始，可选）
setinputsizes(sizes)          　　　　　设置允许的最大输入大小（必须有，但是实现是可选的）
setoutputsize(size[,col])   　　　　　　设置大列获取的最大缓冲区大小（必须有，但是实现是可选的）

当建立连接后，就可以和数据库进行通信了。游标可以让用户提交数据库命令，并获得查询的结果行。

当游标创建好后，就可以执行查询或命令（或多个查询和命令），并从结果集中取回一行或多行结果。

游标对象最重要的属性是 execute*()和 fetch*()方法，所有针对数据库的服务请求都是通过它们执行的。arraysize 数据属性在为 fetchmany()设置默认大小时非常有用。当然，在不需要时关闭游标是个好主意，而如果你的数据库支持存储过程，可能会用到callproc()。
类对象和构造函数

Date (yr, mo, dy)　　　　　　　　　　　　　　　　  日期值对象
Time (hr, min, sec) 　　　　　　　　　　　　　    时间值对象
Timestamp (yr, mo, dy, hr, min, sec) 　　　　    时间戳值对象
DateFromTicks (ticks) 　　　　　　　　　　　　　  日期对象，给出从新纪元时间（1970 年 1 月 1 日 00:00:00 UTC）以来的秒数
TimeFromTicks (ticks) 　　　　　　　　　　　　　  时间对象，给出从新纪元时间（1970 年 1 月 1 日 00:00:00 UTC）以来的秒数
TimestampFromTicks (ticks) 　　　　　　　　　　  时间戳对象，给出从新纪元时间（1970 年 1 月 1 日 00:00:00 UTC）以来的秒数
Binary (string) 　　　　　　　　　　　　　　　　  对应二进制（长）字符串对象
STRING 　　　　　　　　　　　　　　　　　　　　　 表示基于字符串列的对象，比如 VARCHAR
BINARY 　　　　　　　　　　　　　　　　　　　　　  表示（长）二进制列的对象，比如 RAW、BLOB
NUMBER 　　　　　　　　　　　　　　　　　　　　　　表示数值列的对象
DATETIME 　　　　　　　　　　　　　　　　　　　　 表示日期/时间列的对象
ROWID 　　　　　　　　　　　　　　　　　　　　　　表示“行 ID”列的对象
 

连接数据库
以MySQL为例：
打开cmd输入：pip3 install mysqlclient 安装mysql驱动

>>> import MySQLdb as mysql         导入MySQL驱动重名为mysql
>>> conn = mysql.connect('127.0.0.1','root','root')            连接数据库
>>> conn = mysql.connect(host='127.0.0.1', port=3306, user='root', passwd='root', db='test', charset='utf8')        也可以使用关键字连接数据库
>>> config = {
    'host': '127.0.0.1',
    'port': 3306,
    'user': 'root',
    'passwd': 'root',
    'db': 'test',
    'charset': 'utf8'
}
>>> conn = mysql.connect(**config)        也可以使用字典连接数据库
>>> cur = conn.cursor()　　　　　　创建cursor对象
>>> cur.execute('create table users (id varchar(20) primary key, name varchar(20))')         创建users表
>>> id = 1
>>> name = "smelond"
>>> cur.execute("insert into users values('%s','%s')" % (id,name))            插入一行记录，注意MySQL的占位符是%s
>>> cur.execute("update users set id=2 where id=1")                      修改一行记录
>>> cur.execute("select * from users")                    查询记录
>>> values = cur.fetchall()                    将查询的记录赋给values
>>> values                                         输出values
(('2', 'smelond'),)
>>> cur.execute("insert into users values(3,'admin')")                     再次添加记录
>>> cur.execute("select * from users")
>>> values = cur.fetchall()
>>> values
(('2', 'smelond'), ('3', 'admin'))
 
>>> conn.commit()             提交
>>> cur.close()              关闭cursor
>>> conn.close()                关闭connection

ORM技术（sqlalchemy）
在Python中，最有名的ORM框架是SQLAlchemy

安装SQLAlchemy

pip3 install sqlalchemy

# 导入模块
from sqlalchemy import Column, String, create_engine, INT
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
 
# 创建对象的基类:
Base = declarative_base()
 
 
# 定义User对象
class User(Base):
    __tablename__ = "users"
 
    # 表的结构
    id = Column(INT, primary_key=True)
    name = Column(String(20))
 
 
# 初始化数据库连接
# create_engine()用来初始化数据库连接。SQLAlchemy用一个字符串表示连接信息
engine = create_engine("mysql://root:[email protected]:3306/test")
# 创建DBSession类型
DBSession = sessionmaker(bind=engine)

向数据库表中添加一行记录。
由于有了ORM，我们向数据库表中添加一行记录，可以视为添加一个User对象：

# 创建session对象
session = DBSession()
# 创建新User对象
new_user = User(name='smelond')  # 由于我在数据库里面设置id为主键，并且自动增长，所以这个地方可以不带id。
# 添加到session
session.add(new_user)
# 提交即保存到数据库
session.commit()
# 关闭session
session.close()

关键是获取session，然后把对象添加到session，最后提交并关闭。DBSession对象可视为当前数据库连接。

查询记录：

# 创建session对象
session = DBSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果条用all()则返回所有行：
result = session.query(User).filter(User.name == 'smelond').one()
print("type:", type(result))
print("name:", result.name)
session.close()
 
 
结果:
type: <class '__main__.User'>
name: smelond

从上面我们可以看出“还是ORM比较好用”。
文章就学到了，大家慢慢消化了，有什么都不懂了，可以加下python解答学习群：数字778数字747数字511