百度360必应搜狗淘宝本站头条
nodejsbufferorg.jsoupsetnocountoncv2.bitwise_nottime.strptime
当前位置：网站首页 > 编程字典 > 正文

Python基础知识笔记（python 基础入门）

toyiye 2024-08-27 22:03 4 浏览 0 评论

以守护进程运行python脚本，nohup python test1.py &

1.基础知识

1.0 包package


python package需要有一个名为init.py的文件，不然就是普通的package，则无法import package下的模块。可以在init.py文件里写入要被使用的模块，这样import package时，系统会直接去init.py里面寻找模块或者函数。


  • 当导入一个package时，python解释器会首先在内置模块中寻找，若没有则在sys.path列表中寻找。参考


1.1 变量命名规则


python变量名只能包含以下字符：大小写字母、数字、下划线(_)，名称不允许以数字开头。并且以下划线开头的名字有特殊含义。


1.2 可变对象与不可变对象


  • 可变对象：列表list、字典dict、集合set
  • 不可变对象：数值(int,float)、字符串(str)、元组(tuple)


1.3python容器


  • 列表


创建列表：a=[],a=list()
赋值：a=[],b=a  此时，a,b共享同一个对象。
复制(新表)：a=[],b=a.copy(),c=list(a),d=a[:]  此时b，c，d是新的对象，不共享，和a没有任何关系。属于浅复制；浅复制只复制一层(外层)


  • 元组


创建元组：a=(),a=tuple()  a=(1,)等价于a=1,
元组元素不可更改


  • 字典


创建字典：a={}，a=dict()
复制：copy()
赋值：=


  • 集合


创建集合：a=set(),a={1}
集合运算：交集(&),并集(|),差集(-)


1.4 格式化


python有两种格式化方式，习惯称为旧式和新式；这两种方式在python2和python3中都适用。


  • 使用%的旧式格式化


旧式格式化的形式为：string % data，其中string包含的式待插值序列。


 >>> '%s'%4.12
'4.12'
>>> '%f'%4.12
'4.120000'
>>> "my name is %s,age is %d "%('ss',14)
'my name is ss,age is 14 '
>>> "%10d %10f %10s"%(12,11,'dad')  #设置最小域宽度为10格字符，左侧用空格补充
'        12  11.000000        dad'
>>> "%-10d %-10f %-10s"%(12,11,'dad')  #左对齐
'12         11.000000  dad       '
>>> '%.4f %.3d'%(12.13131,11)  #数据截断，设置最大字符宽度
'12.1313 011'


  • 使用{}和format的新式格式化


>>> '{}{}'.format(12,13)
'1213'
>>> '{1}{0}'.format(12,13)  #指定插入的顺序，参数从0开始。
'1312'
>>> '{m}{n}'.format(n=12,m=13)  #命名变量参数
'1312'
>>> '{1:d} {0:f}'.format(12,13)  #使用:实现格式化类型
'13 12.000000'
>>> '{1:<4d} {0:<5f}'.format(12,13)  #左对齐<，右对齐>,居中^
'13   12.000000'
>>> '{1:^4d} {0:<5.3f}'.format(12,13) #精度和旧式一样，但也有不同
' 13  12.000'
>>> '{:^4.3}'.format(12)  #新格式中无法对整数设定精度
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>


1.5 代码注释


#单行注释1
print(123)#单行注释2

#多行注释1
#ddd
#ddd
#ddd

'''
多行注释2
ddd
'''


1.6 python2 VS python3


1.6.1 print


在python3中，print是函数，使用 print('helloworld')
            不换行输出，print("hello",end="") 
                      print("world")   输出：helloworld
在python2中，print是关键字，print "helloworld"
            不换行输出，pring "hello", 
                      print "world"   输出：hello world (以空格分割)


1.6.2 input


--------python2
>>> a=input()      #会做计算处理
12
>>> print a,type(a)
12 <type 'int'>
>>> a=raw_input()   #对输入都以字符串处理
12
>>> print a,type(a)
12 <type 'str'>
>>>
--------python3
>>> a=input()
12
>>> print(a)
12
>>> print(type(a))  #所有输入都作为字符串处理
<class 'str'>
>>>


1.6.3 整除


-----------python2
>>> print 5/2    #向下取整
2        
-----------python3
>>> print (5/2)  #默认进行浮点数除法
2.5
>>> print (5//2)  #取模
2


1.6.4 range


-------------python2
>>> print range(4)   #返回列表
[0, 1, 2, 3]
------------python3
>>> print(range(4))  #返回range对象
range(0, 4)
#循环访问py2和py3基本一样


1.6.5 字符串


python3表示字符串的两种类型：bytes和str，前者的实例包含原始的8位值(一个字节)，后者实例包含unicode字符。
python2表示字符串的两种类型：unicode和str，前者包含Unicode字符，后者包含原始的8位值。
二进制转化为Unicode字符，使用decode；Unicode字符转二进制，使用encode。


1.6.6 列表推导产生的变量泄漏问题


  • python2


>>> x = 'my precious'
>>> dummy = [x for x in 'ABC']
>>> x
'C'
>>> dummy
['A', 'B', 'C']


  • python3


>>> x = 'my precious'
>>> dummy = [x for x in 'ABC']
>>> x
'my precious'
>>> dummy
['A', 'B', 'C']


python2中，在列表推导中同名变量的赋值可能会影响上下文环境；而在python3中，都有自己的局部作用域。使用生成器则不会出现这种变量泄漏问题。


1.6.7 import


python2默认是按照相对路径导入模块和包，python3默认则是按照绝对路径导入。
python2引入一个module时会先在当前目录搜索，然后再去搜索路径(sys.path)搜索；而python3直接在搜索路径搜索，为了导入，使用显式路径导入。


Python2.x 缺省为相对路径导入，Python3.x 缺省为绝对路径导入。绝对导入可以避免导入子包覆盖掉标准库模块（由于名字相同，发生冲突）。如果在 Python2.x 中要默认使用绝对导入，可以在文件开头加入如下语句：


from __future__ import absolute_import


这句 import 并不是指将所有的导入视为绝对导入，而是指禁用 implicit relative import（隐式相对导入）, 但并不会禁掉 explicit relative import（显示相对导入）。


from .foo import Foo    #python2、3都适用
from .bar import Bar    #python2、3都适用
#from mdl.foo import Foo    #python2、3都适用
#from mdl.bar import Bar    #python2、3都适用
#from foo import Foo    #python3不适用
#from bar import Bar    #python3不适用


1.6.8 Exception


py2 : except exc, var
py3 : except exc as var,使用 as 作为关键词


1.6.9 不等运算符


Python 2.x中不等于有两种写法 != 和 <>
Python 3.x中去掉了<>, 只有!=一种写法


1.6.10 dict方法


py2中dict的keys()、items()、values() 是列表,iteritems()返回迭代器
py3中dict的keys()、items()、values() 是类或迭代器，非基础数据类型，执行json的加解密时，需要注意
py3中iteritems() 和 viewitems() 这两个方法都已经废除了，而items()得到的结果是和py2里面viewitems()一致的。在py3里用items()替换iteritems() ，可以用于for来循环遍历


1.6.11 数据类型


在Python2中long是比int取值范围更大的整数，Python3中取消了long类型，int的取值范围扩大到之前的long类型范围。
python3版本中增加了bytes类型


1.6.12 重载


当我们想对python中原有的模块进行覆盖，又不希望退出当前的程序，就需要用到重载的概念


# python2 内置函数
reload(module)

# python3 
from importlib import reload
reload(module)


1.7 项目依赖库安装


  • pip freeze > requirements.txt 导出项目的依赖。
  • pip install -r requirements.txt 在项目中一次性安装依赖


1.8 用venv 配置不同的开发环境


  • pip install virtualenv
  • 进入到项目目录，执行virtualenv --no-site-packages venv(虚拟环境到名字) no-site-packages意思是不复制系统到安装包，得到的是纯净的环境
  • 激活虚拟环境 source venv/bin/activate。进入了venv环境，pip包时只安装到该环境下，系统python环境不受任何影响(windows系统venv\Scripts\activate)，激活后Python 解释器的路径就被添加进PATH 中。
  • 退出虚拟环境 deactivate,回到系统python环境


python3内置了用于创建虚拟环境的venv，可直接使用python3 -m venv .venv（Linux下）


py -3 -m venv .venv


virtualenv --python=/usr/local/bin/python3 env3 #创建指定python版本的虚拟环境 --python 指定python解释器


1.9.代码风格


  • 折叠长行的首选方法是在小括号，中括号，大括号中使用Python隐式换行。长行可以在表达式外面使用小括号来变成多行。连续行使用反斜杠更好。
  • 和None比较用is
  • 缩进使用4个空格，而不要用tab
  • 不要在for和while后面用else
  • 为变量赋值时，赋值符号的左右侧应该各自写上一个空格。
  • 文件中的函数和类之间应该用两个空行隔开。
  • 在同一个类中，各方法之间应该用一个空行隔开。


1.10.新式类和旧式类


python2中既有新式类又有旧式类，并且默认为经典类，只有显示继承object才是新式类。


class a(Object):pass    #新式类写法
class a():pass        #经典类(旧式类)写法
class a:pass            #经典类写法       
类.mro()      #查看解析顺序列表，只有新式类有该属性。    
----------------------------------------------------------------------
class a():
    pass
c=a()
print dir(c)
---------------------------------out
['__doc__', '__module__']
class a(object):
    pass
c=a()
print dir(c)
----------------------------   ---out
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
*:在编写python类时，尽量使用新式类，其包含更多属性。


python3中只有新式类，默认式新式类，不必显式继承object。
新式类增加了slots内置属性, 可以把实例属性的种类锁定到slots规定的范围之中。


如果类是经典类，在多继承的情况下，会按照深度优先方式查找；如果类是新式类，在多继承的情况下，会按照广度优先方式查找；


1.11.python序列化


什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。
json是可以在不同语言之间交换数据的，而pickle只在python之间使用。json只能序列化最基本的数据类型，而pickle可以序列化所有的数据类型，包括类，函数都可以序列化。


序列化的目的：


  • 以某种存储形式使自定义对象持久化。
  • 将对象从一个地方传递到另一个地方。
  • 使程序更具维护性。


1.11.1 Json序列化


用于字符串 和 python数据类型间进行转换

Python

JSON

dict

object

list, tuple

array

str, unicode

string

int, long, float

number

True

true

False

false

None

null

JSON

Python

object

dict

array

list

string

unicode

number (int)

int, long

number (real)

float

true

True

false

False

null

None


-----------------------------loads和dumps---------------------------
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
-------------------------load和dump----------------------------
import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2


1.11.2 pickle序列化


用于python特有的类型 和 python的数据类型间进行转换。pickle操作文件时，需要以二进制的方式操作。


import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)   #f.write(pickle.dumps(struct_time))
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)  #struct_time2=pickle.loads(f.read())
print(struct_time2.tm_year)


1.11.3 json序列化非基本数据类型


如果目标对象是基本数据类型，则不会执行转换方法


import json

class Info(object):
    def __init__(self,name,age):
        # super().__init__()
        self.name=name
        self.age=age

info=Info("selfeasy",12)

#由于json不支持将对象转为为序列化对象，所以需要做转换处理，实现default方法
'''两种转换方式
1. 实现default参数所指定的方法
2. 继承JSONEncoder，并实现default方法
'''
# 1. 实现default方法, 当反序列化时，为了保持原来的目标对象，需要实现object_hook所指向的函数方法
def makeJson(obj):
    return dict(name=obj.name,age=obj.age)

def load_Json(obj):
    return Info(obj['name'], obj['age'])

a=json.dumps(info, default=makeJson)
print(a)
print(json.loads(a,object_hook=load_Json))


# 2.继承JSONEncoder,实现default方法

class JsonMake(json.JSONEncoder):
    def default(self, o):
        if isinstance(o,Info):
            return dict(name=o.name,age=o.age)
        return super().default(o)

a=json.dumps(info, cls=JsonMake)
print(a)
print(json.loads(a,object_hook=load_Json))


1.12.猴子补丁(Monkey patch)


在动态语言中，不去改变源码而对功能进行追加和变更，是在程序运行的过程中去修改。
1.追加功能 2.功能变更 3.修正程序错误
4.增加钩子，在执行某个方法的同时执行一些其他的处理，如打印日志，实现AOP等。


class XiaoMing(object):
    def favorite(self):
        print "apple"

class God(object):
    @classmethod
    def new_xiaoming_favorite(cls):
        print "banana"

    @classmethod
    def monkey_patch(cls):
        XiaoMing.favorite = cls.new_xiaoming_favorite

God.monkey_patch()

xiaoming = XiaoMing()
xiaoming.favorite()
>> banana


1.13.上下文管理器


上下文管理器是一个对象，为操作提供了额外的上下文消息，以一种优雅的方式将额外的处理封装起来。如果一个类实现了__enter__和__exit__方法则表明该类的实例是一个上下文管理器。上下文管理器通常和with搭配使用。实现上下文管理器的两种方式：类和装饰器


  • 类实现上下文管理器


class context(object):
    def __init__(self):
        print ('上下文管理器初始化')
    
    def __enter__(self):
        print("上下文管理器开始执行")
        return self
    
    def __exit__(self,exec_type, exec_value, exec_traceback):
        print ("上下文执行结束")

    def operator(self):
        print (1/2)
with context() as obj:
    obj.operator()
--------------------------------out
上下文管理器初始化
上下文管理器开始执行
0.5
上下文执行结束


备注 :当operator改为1/0时，程序执行后抛出异常；但是当在exit方法中返回True时(默认为False)，程序不会报错，因为结果返回true就表示告诉python解释器，异常已捕获并解决，不需要往外抛了。


  • 装饰器实现上下文管理器
    可以不用写一个类来实现上下文管理器，类的实现过于繁杂。python提供了一个装饰器，只需按照它的协议来实现函数内容，即可以将该函数对象变成一个上下文管理器。


from contextlib import contextmanager
from traceback import format_exc
@contextmanager
def context(a,b):
    print ("上下文管理器开始运行")  #enter方法
    f=a/b
    try:
        yield f
    except Exception:
        print ("处理异常")
    finally:
        print("finally")


with context(1,2) as f:
    print (123)
    print(f)
----------------------------------out
上下文管理器开始运行
123
0.5
finally


备注:try之前的代码会在装饰器的__enter__方法中执行；当执行到yield时，它的产出值会作为__enter__的返回值，赋值给as后的变量。当with块的代码执行完成后，上下文管理器会在yield处恢复，继续执行yield后的代码，后面的代码在装饰器的__exit__方法中被调用。
当程序发生异常时，后面的代码不会执行(包括finally代码)


上下文管理器类与@contextmanager中最大的区别在于对异常的处理。以类的方式实现的上下文管理器，在引发异常时，exit方法内的代码仍会正常执行；而以生成器函数实现的上下文管理器，在引发异常时，exit方法会将异常传递给生成器，如果生成器无法正确处理异常，则yield之后的代码不会执行。


1.14. 可散列的数据类型


如果一个对象是可散列的，那么在这个对象的生命周期中，它的散列值是不变的，而且这个对象需要实现 __hash__() 方法。另外可散列对象还要有 __eq__() 方法，这样才能跟其他键做比较。如果两个可散列对象是相等的，那么它们的散列值一定是一样的。原子不可变数据类型(str、bytes 和数值类型)都是可散列类型。


1.15. Python 运行时


python -m xxx  #相当于import，当作模块运行，当前脚本路径不会加入到sys.path中。
python xxx.py  #直接运行，当前脚本路径会加入到sys.path中。

python -m site #显示sys.path的值内容，即python搜索模块的目录


1.16. 原地操作


许多运算符都有原地操作，如add方法对应的原地操作是iadd。python中的运算符和operator模块中的函数是对应的


  • 不可变类型的目标


对于不可变的目标如字符串、数字、元组等，当调用一个原地方法是，分两步执行，运算和赋值。当调用原地函数时，只执行运算嘛，不执行赋值操作。如下：


>>> import operator
>>> a="hello"
>>> operator.iadd(a, ' world')#若要更新变量，则需要执行赋值操作，即a=operator.iadd(a, ' world')
'hello world'
>>> a
'hello'


  • 可变类型的目标
    对于可变的目标，如列表、字典，原地方法将执行更新，因此不需要后续赋值操作。如下:


>>> import operator
>>> s = ['h', 'e', 'l', 'l', 'o']
>>> iadd(s, [' ', 'w', 'o', 'r', 'l', 'd'])
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> s
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']


1.17 python -c 和-m区别


0. python xxx.py 直接运行
1. python -m xxx.py当作模块执行，相当于import
2. python -c 当作命令，脚本执行


1.18 查看包搜索路径的几种方法


import sys
from pprint import pprint
pprint(sys.path)


python -c "import sys;print sys.path"


python -m site


1.19 快速构建HTML帮助文档


python -m pydoc -p 8180 #开启本地http服务


1.20 字符串转义


正则表达式re中就用到了转义


当字符串中使用到特殊字符时，有时候我们不想让其发生转义，而想原样式输出，我们可以使用r字符来定义原始字符串。如下：


str = 'Python\nJava' 
print(str)
# out 
Python
Java

str = r'Python\nJava'
print(str) 
# out
Python\nJava


2.错误解决方法


2.1 ImportError错误


  1. 普通的package和python packae


     错误分析</strong>:from package import xxx 时，package无法被识别为python package
     解决办法：在package下新建__init__.py即可，此时package被视为python package


  1. 循环导入


    from a  inport b  # module a
    from b import a   # module b


解决办法:


  1. 在模块的最后使用import语句。
  2. 在函数内导入模块(即使用到该模块内容的函数内部)

相关推荐

# Python 3 # Python 3字典Dictionary(1)

Python3字典字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中,格式如...

Python第八课:数据类型中的字典及其函数与方法

Python3字典字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值...

Python中字典详解（python 中字典）

字典是Python中使用键进行索引的重要数据结构。它们是无序的项序列(键值对)，这意味着顺序不被保留。键是不可变的。与列表一样，字典的值可以保存异构数据，即整数、浮点、字符串、NaN、布尔值、列表、数...

Python3.9又更新了:dict内置新功能，正式版十月见面

机器之心报道参与：一鸣、JaminPython3.8的热乎劲还没过去，Python就又双叒叕要更新了。近日，3.9版本的第四个alpha版已经开源。从文档中，我们可以看到官方透露的对dic...

Python3 基本数据类型详解（python三种基本数据类型）

文章来源：加米谷大数据Python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在Python中，变量就是变量，它没有类型，我们所说的"类型"是变...

一文掌握Python的字典（python字典用法大全）

字典是Python中最强大、最灵活的内置数据结构之一。它们允许存储键值对，从而实现高效的数据检索、操作和组织。本文深入探讨了字典，涵盖了它们的创建、操作和高级用法，以帮助中级Python开发...

超级完整|Python字典详解（python字典的方法或操作）

一、字典概述01字典的格式Python字典是一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等其他容器模型。字典的每个键值key=>value对用冒号:分割，每个对之间用逗号,...

Python3.9版本新特性:字典合并操作的详细解读

处于测试阶段的Python3.9版本中有一个新特性：我们在使用Python字典时，将能够编写出更可读、更紧凑的代码啦！Python版本你现在使用哪种版本的Python？3.7分？3.5分？还是2.7...

python 自学，字典3(一些例子)（python字典有哪些基本操作）

例子11；如何批量复制字典里的内容2；如何批量修改字典的内容3；如何批量修改字典里某些指定的内容...

Python3.9中的字典合并和更新，几乎影响了所有Python程序员

全文共2837字，预计学习时长9分钟Python3.9正在积极开发，并计划于今年10月发布。2月26日，开发团队发布了alpha4版本。该版本引入了新的合并(|)和更新(|=)运算符，这个新特性几乎...

Python3大字典:《Python3自学速查手册.pdf》限时下载中

最近有人会想了，2022了，想学Python晚不晚，学习python有前途吗？IT行业行业薪资高，发展前景好，是很多求职群里严重的香饽饽，而要进入这个高薪行业，也不是那么轻而易举的，拿信工专业的大学生...

python学习——字典（python字典基本操作）

字典Python的字典数据类型是基于hash散列算法实现的，采用键值对(key:value)的形式，根据key的值计算value的地址，具有非常快的查取和插入速度。但它是无序的，包含的元素个数不限，值...

324页清华教授撰写【Python 3 菜鸟查询手册】火了，小白入门字典

如何入门学习python...

Python3.9中的字典合并和更新，了解一下

全文共2837字，预计学习时长9分钟Python3.9正在积极开发，并计划于今年10月发布。2月26日，开发团队发布了alpha4版本。该版本引入了新的合并(|)和更新(|=)运算符，这个新特性几乎...

python3基础之字典（python中字典的基本操作）

字典和列表一样，也是python内置的一种数据结构。字典的结构如下图:列表用中括号[]把元素包起来，而字典是用大括号{}把元素包起来，只不过字典的每一个元素都包含键和值两部分。键和值是一一对应的...

取消回复欢迎 你 发表评论:

请填写验证码
一周热门
最近发表
标签列表