python从入门到精通合集（一）

所有示例基于python3.7.4版本

提示：以下是本篇文章正文内容，下面案例可供参考

一、python是什么？

Python是一门编程语言
Python是一种解释型、面向对象、动态数据类型的高级程序设计语言
特点：
优点：                               缺点：
	开发效率第一                         运行速度慢（C：1秒，Java:2秒，python:10秒）
	学习曲线第一                         代码不能加密
	生态圈第一

二、python安装

直接安装anaconda

anaconda 是一个python的发行版，包括了python和很多常见的软件库, 和一个包管理器conda。   

官网下载：https://www.anaconda.com/distribution/
清华大学镜像下载：https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/

三、python基础

1.输入和输出

python示例：

name=input('请输入你的名字:')    #输入
print(name)                      #输出
print('hello world')             #输出字符串
print('你好', '世界', '我爱你')   #print()会依次打印每个字符串，遇到逗号“,”会输出一个空格

Java示例：

public class Test1 {
    
    
    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);    #入口
        String i = scanner.nextLine();             
        System.out.print(i);                 #输出
    }
}

2.变量和常量

• 变量

  Python 中的变量赋值不需要类型声明
  每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
  创建变量时会在内存中开辟空间
  基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中
  

python示例：

a=13
b=52
print(a+b)   #65

• 常量 （变量名大写即可）

PI=3.1415
print(PI)

3.六大标准数据类型

• Number（数字）

  Python3 支持 int、float、bool、complex（复数）。
  int 整数型   3
  float 浮点型 3.0
  bool 布尔类型    True       False
  complex（复数）   3j  
  

  python示例：

num1=3
num2 = 3.5 
num3=3.14j
num4=True
print(type(num1))
print(type(num2))
print(type(num3))
print(type(num4))

结果：

• String（字符串）
  python示例：

str1='我是奥特曼'
print(str1)
print(str1[2])   #取下标为2的元素
print(str1[-1])  #取最后一个元素
print(str1[2:5]) #取下标从2开始到5的元素
print(len(str1)) #求字符串的长度

结果：

• List（列表）

  list是一种有序的集合，可以随时添加和删除其中的元素。（长度可变）
  

  python示例：

staff_list=["刘恒","胡瑞"]
staff_list.append("常铭")       #给列表末端增加元素
staff_list.insert(0,"甲流")     #给列表下标为0处增加元素
information=["佩奇","牛马"]
str3=information+staff_list    #列表合并
str3.remove("常铭")             #移除指定的元素
#pop()方法是删除末尾的元素
name1=str3.pop(2)               #删除下标为2的元素
print(staff_list)
print(str3)
str4="1,2,3,4,5,6"
list1=str4.split(",")    #以逗号为标志将字符串转换为列表
print(list1)
str5="".join(list1)      #列表转换为字符串
print(str5)

结果：

• Tuple（元组）

  有序列表元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改（不可变）
  

  python示例：

t1 = (1, 2)
t2 = (1, )
t3 = (1) #此类型不是tuple，为了防止被误解成数学意义上的括号
t4 = ()

结果：

• Dictionary（字典）

  dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储
  

  python示例：

l= {
    
    'Michael':95,'Bob':75,'Tracy':85}
print(l['Bob'])       #打印key为Bob的值
#print(l['liu'])      # key不存在时报KeyError: 'liu'
print('liu' in l)     #判断key=liu是否在字典里
#dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value
err=l.get('liu')
print(err)
err=l.get('liu',-1)
print(err)
l.pop('Michael')      #删除指定的key
print(l)
l['刘恒']=100          #增加key
print(l)

结果：

注意：dictdict的key必须是不可变对象。（列表不可以作为key）
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

• Set（集合）

   set 和dict类似，也是一组key的集合，但不存储value。
   创建set时需要提供一个list作为一个输入集合
  `python示例：`     
  

s= set([1,2,3,4,5,5])  #重复的元素在set中自动被过滤
print(s)
s.add(6)        #增加元素6
s.remove(4)     #移除元素4
print(s)

结果：

4.单引号双引号三引号用法

python示例：

str1='我是奥特曼'
print(str1)
str2="我是奥特曼"
print(str2)
str3="""
     有志者事竟成
     万事开头难
     努力总比懒惰强
            ——————刘恒
            """
            #保存格式输出
print(str3)
'''
这是多行注释，用三个单引号
"""
这是多行注释，用三个双引号
"""

结果：

5.字符串编码和格式化

• 字符串编码

  unicode编码包含了ASCII和UTF-8，在python最新的版本中，字符串是以Unicode编码的，也就是说Python的字符串支持多语言
  

  python示例：

x = b'ABC'
y ="ABC"
print(x==y)  #前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
#通过encode()方法可以编码为指定的编码格式
z='中'.encode('ascii')  #报错UnicodeEncodeError:中文编码的范围超过了ASCII编码的范围
print(b'ABC'.decode('ascii')) #把bytes变为str
z=b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')  #忽略错误的字节
print(z)

结果：

• 字符串格式化

  第一种：在Python中，采用的格式化方式和C语言是一致的，用%实现 
  常见的占位符：
  

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

python示例：

print('hello  %s'% '刘恒')
print(' 我是浮点数%f,我是整数%d ，我是十六进制整数%x'% (3,3,233)))

结果：

第二种方法：使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……

python示例：

print( 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125))

结果：

第三种方法：f-string       r-string(表明这是个路径)

python示例：

name = "刘恒"
print(f"我的名字是{
      
      name}")
import pygame
pygame.mixer.music.load(r"C:\Users\文帝\Desktop\Zyboy忠宇 - 妈妈的话.mp3")

结果：

6.缩进规则

C、C++、Java、C#、Rust、Go、JavaScript 等常见语言都是用"{“和”}"来标记一个块作用域的开始和结束
Python 程序则是用缩进来表示块作用域的开始和结束
Python 对缩进有严格的要求，同一个源文件里，缩进必须保持一致
python示例：

a=100
if a<99:
    print("不及格")
print("你是个大彩笔")

7.条件判断和循环

if else判断语句
python示例：

age = 3
if age >= 18:
    print('your age is', age)
else:
    print('your age is', age)

if elif else判断语句
python示例：

p_num=input()
#input输入的都是字符串
if p_num==5:
    print("猜错了")
elif p_num=="5":
    print("猜对了")
else :
    print("你猜")
print(p_num)

for in循环语句
python示例：

names=["张三","李四","王麻子"]
for name in names:
    print(name)

while循环语句
python示例：

L = ['Bart', 'Lisa', 'Adam']
i=0;
while  i<3:
    print(L[i])
    i=i+1

8.break和continue语句

continue语句

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

break语句

n = 1
while n <= 100:
    if n > 2: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')

9.运算符

关于运算符菜鸟教程讲得非常清楚：菜鸟教程
注意：

print(9/3) #/除法的结果是浮点数
print(9//3)#//除法的结果永远是整数
print(9%3)#取余 

10.函数

（1）定义函数

• 空函数
  python示例：

def nop():
    pass

• 普通传参
  python示例：

def sum_sub(a,b):
    x=a+b
    y=a-b
    return x,y
x,y=sum_sub(2,1)
print(x,y)
print(sum_sub(2,1))  #python的返回值是单一值，是tuple

• 默认参数
  python示例：

def city(x,y="刘恒"):
    print("城市",x)
    print("姓名",y)
city("西安")

定义默认参数要牢记一点：默认参数必须指向不变对象！

• 关键字传参

  关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
  

python示例：

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
person('Adam', 45, gender='M', job='Engineer')
extra = {
    
    'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, city=extra['city'], job=extra['job'])
person('Jack', 24, **extra)

• 命名关键字参数

  命名关键字参数：目的是为了限制关键字参数的名字
  如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
  

python示例：

def person(name, age, *,city):
  print('name:', name, 'age:', age,city)
person('刘恒',22,city='Engineer')
def person(name, age,*args,city):
  print('name:', name, 'age:', age,city)
person('刘恒',22,'Engineer')  #报错TypeError: person() missing 1 required keyword-only argument: 'city'

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
（2）匿名函数

     lambda x: x * x
     等同于：
     def f(x):
         return x * x

python示例：

f=lambda x: x * x
print(f(2))
#用作返回值
def build(x, y):
    return lambda: x * x + y * y
z=build(1,2)
print((build(1,2)))#相当于形成闭包
print(z())

（3）递归函数
递归实现n!

def jie(n):
    if n==1:
        return 1
    return n*jie(n-1)
print(jie(3))

递归次数过多将会导致栈内存溢出RecursionError: maximum recursion depth exceeded

（4）偏函数

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。 

python示例：

a=int('123')  #int函数还提供额外的base参数，默认值是10
b=int('123',base=16)   
print(a)
print(b) #16制变换
#如果转换大量的字符串，会特别麻烦，我们可以定义一个函数，将base=2上传进去
def int2(x, base=2):
    return int(x, base)
#第二种，帮助我们创建一个偏函数
import functools  
h  = functools.partial(int, base=2)
print(h('1000000'))

（5）常用高阶函数

#所谓的高阶函数就是让函数的参数能接受别的函数
def add1(x,y,f):
    return f(x)+f(y)
print(add1(-5, 6, abs))
#把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！
#当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复abs函数，请重启Python交互环境。
#python中常用的高阶函数
#map(第一个参数为函数，第二个参数为Iterable可迭代对象)
string=map(str,[1,2,3,4,5])
print(string)  #返回一个map对象  <map object at 0x000001A1E2529288>
from collections.abc import Iterable  
print(isinstance(string, Iterable))   #返回的string对象是可迭代对象
#Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
#可迭代对象是惰性的，通过list()函数把整个序列计算出来
print(list(string) )
#reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
from functools import reduce
def add(x, y):
    return x+y
print(reduce(add,[1,2,3,4]))
#filter函数和map类似filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
def  compare (n) :
    if(n>5):
        return n
print(filter(compare,[1,3,6,7]))  #<filter object at 0x000001A1E2520648>
print(list(filter(compare,[1,3,6,7])) )
#sorted函数 进行排序
print(sorted([-2,6,1,0,-8,3]))
print(sorted([-2,6,1,0,-8,3],key=abs)) # key函数返回的结果进行排序
print(sorted([-2,6,1,0,-8,3],key=abs,reverse=True)) #反向排序
#函数返回函数-函数内部创建新的函数，内部函数可以引用外部函数的参数和局部变量，当返回函数sum时，相关的变量和参数都保存在返回的函数中形成闭包
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f1 = lazy_sum(1, 3, 5, 7, 9)
print(f1)
print(f1())
f2= lazy_sum(1, 3, 5, 7, 9)
print(f1==f2)#每次调用都会产生新的函数
#返回函数不要引用任何循环变量，或者后续会发生变化的变量。
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count()
print(f1())   #返回的f函数存在于循环中，每次村换都会产生新的f函数返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。
print(f2())
print(f3())
def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs
f1, f2, f3 = count()
print(f1())  
print(f2())
print(f3())
def inc():
    x = 0
    def fn():
        nonlocal x  #不加这个会报UnboundLocalError: local variable 'x' referenced before assignment
        x = x + 1  #x为外部局部变量，当在fn中修改时，会将x视为fn的局部变量，会屏蔽inc中对x的定义
        return x
    return fn

f = inc()
print(f()) # 1
print(f()) # 2