一、Python概述

1.概述
Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间编写的。
Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容，被形象地称作“内置电池”。用Python开发，许多功能不必从零编写，直接使用现成的即可。
龟叔给Python的定位是”优雅“、”明确“、”简单“，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常复杂的程序。

2.Python应用
a.网站后台开发-PythonWeb
b.日常小工具 运维脚本
c.将其他语言开发的程序包封装起来 方便调用-胶水语言
d.爬虫开发-python爬虫
e.科学计算AI领域有独特优势-python是人工智能语言

3.Python
优点：
简单易学
完善的语言特性
天然开源
丰富的社区支持
缺点：
慢
python是一种解释型的语言，编写的代码就是执行码，在python程序执行时，由python的解释器，边读取边解释，边执行，效率比较低。
所以在开发高性能程序时，基本不会考虑python。但是在普通的不追求极致效率的应用的程序时，python慢的缺点体现的并不明显，而python简单 高效的开发能力优势明显，所以被大量的使用
代码无法加密
由于python是一种解释型的语言，编写的代码就是执行码，因此将python程序发布的过程就是将源代码发布的过程，代码无法实现保密的效果，但是正是这样的特点决定了python从语言层面上就是天然开源的，这也是python社区快速发展的原因之一。

二、Python的安装配置使用

1.Python安装配置
方位python官方网站，下载python安装包
https://www.python.org/downloads/
python目前分为两大版本，互不兼容
2.x.x
3.x.x
双击安装
python-2.7.13.amd64.msi
设置环境变量
将python安装位置配置到PATH环境变量下。

2.Python的使用方式
a.shell命令方式
在命令行下以交互执行命令
在cmd命令下通过python命令进入python命令行，交互式编写代码处理数据

b.将python卸载文件中
可以将代码写在.py文件中，再通过python命令执行文件
c.使用IDE工具开发python
①pycharm
官方推荐的python开发工具
②eclipse安装python开发插件
使elipse具有开发python的能力

三、Python语法

1.语法细节
a.编码
python2解析器python文件默认采用iso8859-1。python3模式使用utf-8
如果python文件本身的编码和以上编码不一致会出现乱码问题
此时可以在文件中通过如下注释通知解释器解析当前文件时采用的编码，两码一致可以解决
乱码：

b.造句
python通常一行为一条语句，不需要分号标识
如果将多条语句写在一行内，则需要使用分号分割防止产生歧义
c.缩进
python中没有使用大括号作为作用域的标识，而是采用制表符来标识作用范围

d.注释
python使用#作为单行注释 使用三个单引号 或 三个双引号作为多行注释

e.引用及常量变量
python没有声明引用的关键字，直接写引用的名称就是在声明一个引用。
python的引用没有数据类型的区分，也即一个引用可以先后被指向不同类型的数据。
python中小写的引用标识变量 大写的引用表示一个常量，要注意的时，此处常量只是一种约定，要求未来使用者不要进行修改，但本质上还是变量，如果真的修改也是可以修改成功的。

2.标识符
在python中，所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头。
python中的标识符时区分大小写的。
在python中下划线_是有特殊意义的
1）以单下划线开头_foo的代表不能直接访问类属性，需要通过类提供的接口进行访问，不能用from xxx import *访问：
2）以双下滑线开头的__foo代表类的私有成员
3）以双下划线开头和结尾的__foo__代表python里特殊方法专用的标识，如__init__()代表类的构造方法
3.数据类型
python中的引用时没有数据类型的，但是数据本身是有类型的区别的
a.字符串
可以用单引号，双引号或三引号来声明一个字符串直接量
其中单引号和双引号没什么差别
而三引号声明的字符串可以包含任意字符，这些字符会被直接当作字符串的内容 从而省去转义的过程
python中也可以使用r或R在字符串直接量前进行修饰，表面当前字符串忽略转义直接使用原值

python字符串提供了大量的操作方法：

b.布尔
布尔类型的直接量只有两个值
True False
c.数值
python中代表数据的类型，可以有如下四种直接量的值：
整型
通常被称为是整型或整数，是正或负整数，不带小数点。
长整型
无限大小的整数，整数最后一个大写或小写的L。
浮点型
浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2=2.5 x 10^2=250）
复数
复数由实数和虚数部分构成，可以用a+bj，或者complex(a,b)表示，负数的实部a和虚部b都是浮点型。
数值类型提供了大量的操作方法：

d.空值
类似于java中的null，表示没有值，只有一个直接量
None
x=Node(JAVA:Object = null)

四、运算符

a.算数运算符

b.比较（关系）运算符

c.赋值运算符

d.位运算符

e.逻辑运算符

f.成员运算符

g.身份运算符

h.运算符的优先级

五、语句

a.条件语句
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QuuaFPRe-1654440257030)( https://img-blog.csdnimg.cn/c72654b42d9f4c709984806cefad4c21.png)]

b.循环语句while

c.循环语句for

补充：

六、重要API:集合类

1.列表-list
可以用来存储 内容可变 长度可变 类型可以不同 有序的数据的数据结构
类似于java的List
列表的基本使用：

列表的其他函数：

2.元组 - tuple
元组的列表：
①元组本身是不可变数据类型，没有增删改查
②元组内可以存储任意数据类型
元组的基本使用：

元组的其他函数

3.Set - 涉及集
不可修改 不可重复 无序 类型可以不同 的列表
类似于java中的Set
set的基本用法：

4.字典 - dict
存储键值对类型的数据 键不可重复 无序
类似于java的Map
dict的基本用法：

dict的其他方法：

七、函数

1.定义函数
a.普通函数定义
通过def关键字定义函数，之后跟函数名称和小括号包裹的参数列表，之后跟一个冒号，在其后编写函数体。
函数体的第一行内容，可以直接是一个字符串，此字符串不影响函数体的内容，相当于是该方法的文档说明，用来描述函数的功能，可以在后续查看。
函数内容需要缩进。
通过return关键字在函数内部返回，并可以选择性返回一个返回值，如果return后没有明确的返回值，则默认返回的是一个None。

##定义函数
def sumx(n1,n2):
    "两数求和函数"
    return n1+n2

b.函数直接量定义函数
通过lambda表达式来声明一个函数，lambda关键字之后跟参数列表，再跟冒号，之后是函数的体，这种方式声明的函数体只能是一个表达式，如果函数体有多条语句，则无法通过此方式定义。

##函数直接量定义函数
sumx = lambda arg1,arg2:arg1+arg2
print(sumx(2,3))

2.函数的调用
通过函数名之后跟小括号传入参数值就可以用调用函数了
函数的调用过程中，也可以在实参列表中明确的指定实参要赋值给哪一个形参，从而实参列表的顺序可以和形参列表不同

##函数的调用
def sumx3(n1,n2,n3):
    return n1+n2+n3;
print sumx3(1,2,3)
print sumx3(n3=3,n2=2,n1=1)

3.缺省参数
在定义函数的过程中，可以为全部或部分函数参数指定默认值，则在调用函数的过程中可以选择性的不传入这些参数，则这些参数采用默认值执行函数。

##缺省参数
def sumx4(n1,n2=10):
    return n1 + n2;
print sumx4(2,3)
print sumx4(2)

4.不定长参数
类似于java中的可变参数，python中的函数也可以具有不定长的参数，未来再调用时可以传入0个或多个参数，而在函数的内部可以按照使用数组的方式使用该不定长参数。
可以通过在形参名称之前加*号，将参数设定为不定长参数。
一个函数中，不定长参数最多只能有一个，且必须出现在函数参数列表的最后一位。

##不定长参数
def sumx5(*ns):
    s = 0;
    for x in ns:
        s += x;
    return s;
print sumx5(2,3)
print sumx5(2,3,4)
print sumx5(2,3,4,5)

5.函数是一等公民
在python中函数的一等公民，具有完整的能力，属性能做的函数都可以做。
a.赋值给引用

##函数是一等公民
def sumx6(n1,n2):
    return n1 +n2;
print sumx6(2,3)

sumx7 = sumx6
print sumx7(2,3)

sumx6 = None
sumx7 = None

b.作为类的成员

class Person:
    name = "zs";
    age = 18;
    def eat(self):
        print "吃.."
    def say(self):
        print "说.."

c.作为局部成员

def eat(food):
    def cook(food):
        return "弄熟"+food;
    print "吃"+cook(food)

eat("羊肉串")

d.高阶函数作为方法的参数

def eatx(food,cookFunc):
    food2 = cookFunc(food)
    print "吃"+food2
def cookYRC(food):
    return "烤盘"+food;
eatx("羊肉串",cookYRC)
eatx("涮羊肉",lambda food:"煮熟"+food)

e.高阶函数作为方法返回值

def lookupCP(cai):
    if "羊肉串" == cai:
        def cookYRC(food):
            return "烤熟"+food;
        return cookYRC;
    elif "涮羊肉" == cai:
        return lambda food:"煮熟"+food;
    else:
        return lambda food:"弄熟"+food;

cookFunc = lookupCP("羊肉串")
print cookFunc("羊肉串")
cookFunc = lookupCP("涮羊肉")
print cookFunc("羊肉串")

模块、包

1.模块的概念
Python模块（Module），是一个Python文件.以.py结尾，其中包含了Python对象定义和Python语句等内容。
简单来说，一个Python文件就是一个python模块。
Python是以模块为单位来有结构的组织项目的。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
2.引入模块
在某一个模块中如果用到了其他模块中定义的内容，就需要在当前模块中引入该模块。这个过程类似于java中的导包的过程，在Python中称之为引入模块。
a.引入模块方式1：

#import module[module2[...moduleN]
import math;
print math.floor(3.14)

import Demo01;
print Demo01.sumx(2,3)

b.引入模块方式2：

#from modname import name1[name2[...nameN]]
from math import *
print floor(3.14)

from Demo01 import sumx;
print sumx(2,3)

搜索路径：
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
1）当前目录
2）如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
3）如果都找不到，Python会查看默认路径。UNIX下，默认路径一为/usr/local/lib/python/。Windows下通常c:\…\system32目录下

3.包
包是一个分层次的文件目录结构，用来组织程序结构。（作用和java一样）
简单来说包就是文件夹。
但是在python中并不是所有的文件夹都是包，一个文件夹下必须有一个名为__init__.py文件才会被识别称为包。
__init __.py文件一方面是一个标识，标识当前文件夹是一个包，另一方面，这个文件中代码还会再python包再第一次被使用被执行。

重要API - IO

1.打印

print("abc")

2.键盘读取
a.raw_input函数读取键盘
这种方式的读取，会将输入当作一个字符串返回
str=raw_input(“请输入：”)；
b.input函数读取键盘
这种方式的读取，会将输入当作一个表达式执行，返回的是表达式执行后的结果

str = input("请输入： ")

3.读写文件
open函数操作文件：

file对象的属性

4.系统操作

异常机制

2.捕获异常
当有异常抛出时，可以使用如下方法捕获异常：

3.手动抛出异常
通过raise关键字，可以手动抛出异常

raise [Exception[,args[,traceback]]]

4.自定义异常
可以写一个类继承Exception来开发一个自定义异常

面向对象

1.创建类
使用class关键字来创建一个类，class之后为类的名称并以冒号结尾，后跟类体。
在类体的第一行可以写一个字符串，作为该类的文档声明，这个文档声明可以通过ClassName.__doc__查看：
类的体中可以包含成员属性 成员方法 构造方法等内容

class Person:
    "代表人的类"
    name = ""
    age = "bj"
    def __init__(self,name,age):#self相当于java的this
        self.name = name;
        self.age = age;
    def eat(self):
      print(self.name + "吃。。。。")
    def say(self):
      print(self.name+ "说。。。")

print Person.__doc__
p = Person("zs",18)
print p.name
print p.age
p.eat()
p.say()

2.创建属性
python类中可以包含成员属性。当创建该类的对象时，对象都会默认具有该属性。
3.成员方法
python类中的方法和其他方法不同之处在于，方法中必须存在一个叫self的参数，这个self代表的当前对象的本身，相当于java中的this
4.构造方法
python中的类可以指定构造方法。在python类中定义为__init__的方法，就是python的构造方法。
5.创建对象
python中没有new关键字，直接使用类名就可以创建出对象
6.增加删除对象的属性和方法
在python中，类的和对象关系并不是一种强关联，类仅仅时创建对象的模板，一旦对象创出来，对象就是一个独立的个体，可以自己增加或删除属性和方法。
注意，删除操作只能删除后天增加的属性和方法，对于类中的属性和方法无法删除
另外，可以在对象创建出来后增加删除属性方法，意味着哪怕是同一个类创建的对象，也可以非常的不同。

p1 = Person("ls",20)
#增加属性
p1.addr = "bj"
#增加方法
p1.sumx = lambda n1,n2:n1+n2;
print p1.addr
print p1.sumx(2,3)
#删除属性
del p1.addr
#删除方法
del p1.sumx

7.类的内置属性
python的类自动包含若干内置属性，这些内置属性往往具有特定功能

#__dict__:类的属性(包含一个字典,由类的数据属性组成)
#__doc__类的文档字符串
#__name__类名或模块名
#__module__:类定义所在的模块
#__bases__:类的所有父类构成元素(包含了一个由所有父类组成的元组)
print Person.__doc__
print Person.__dict__
print Person.__module__
print Person.__name__

案例：
如果当前模块是程序的入口，则模块名会被改为__main__,如果不是则模块名等于文件名。
因此，通常在模块中会写这样的代码，从而让模块被直接执行和被import导入是执行不同逻辑

if __name__=='__main__':
    当模块被直接执行时走的逻辑
else:
    当模块被import导入时执行的逻辑

8.类的封装-访问权限控制
python中类的属性和方法都可以直接进行访问权限的控制，控制的方法为：
①属性或方法名称如果以单下划线开头，则表示属性或方法是保护成员，只能在类内部或子类内部访问，但是这仅仅是一种约定，在语法层面并没有这种限制。
②属性或方法名称如果以双下划线开头，则是私有成员，只能在类的内部访问，外界无法使用，这是python语法的一部分。

class Person :
    "代表人的类"
    __name = "zs"
    def __say(self):
      print("说。。。")

p = Person
print(p.__name)#属性私有化，访问不了，访问报错
p.__say()#方法私有化，访问不了，访问报错

9.类的继承
python类支持继承。python支持多继承。
继承的语法:

 class subClass(superClass,[...]):
     类体

子类在构造时并不会自动调用父类的构造方法，如果需要，则应在子类的构造方法中显式的调用父类构造。
在子类中调用父方法时，需要通过父类名来调用。
如果多重继承中，多个父类有同名方法，则具体继承到哪一个取决于父类的继承顺序，继承声明中越靠前优先级越高。
在子类中如果不喜欢父类的方法，可以进行重写操作，在子类中声明和父类名称和参数相同的方法，自己来实现。

class Person :
    "代表人的类"
    name = ""
    age = 20

    def __init__(self,name,age):#self相当于java的this
        self.name = name;
        self.age = age;

    def eat(self):
      print(self.name + "吃。。。。")

    def say(self):
      print(self.name+ "说。。。")

class Coder:
    def code(self):
        print("写代码..")
    def run(self):
        print("加油,飙车..")

class Driver:
    def driver(self):
        print("开车..")

class Teacher(Person,Coder,Driver):
    def teach(self):
        print self.name + "教.."

t = Teacher("ww",33)
t.teach()
t.driver()
t.code()
t.run()

10.类的多态
python中引用没有类型，引用可以先后等于完全不同类型的数据，自然也就没有多态的概念了。
11.基础方法重写
python中的类中自带了很多基础方法，这些方法提供了类的特定的功能，可以通过重写这些方法来覆盖这些特定功能的实现。

__init__(self[,args...]):  (相当于java的构造方法)
    构造方法
__del__(self)
  析构方法,删除一个对象后要做的事
__str__(self)
  用于将值转化为适于人阅读的形式(相当于java中的toString方法)
__cmp__(self,x)
  两个对象比较(相当于java的compareTo方法)

转载自CSDN-专业IT技术社区

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/weixin_44468025/article/details/125112531