python基础知识笔记

最新推荐文章于 2024-02-23 13:34:31 发布

come11234

最新推荐文章于 2024-02-23 13:34:31 发布

阅读量657

点赞数 1

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/come11234/article/details/102707603

版权

python 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

pycharm快捷键

格式化代码：ctrl+shift+l
复制当前行：ctrl+d double
ctrl+y:删除一行
查找：ctrl+f find
替换：ctrl+r replace
全局查找：ctrl+shi+f
全局替换：ctrl+shi+r
查找文件名：double shift
格式化代码：ctrl+shift+/ 多行注释
Ctrl+Alt+Left/Right 后退、前进

python内置函数

在这里插入图片描述

基本数据类型

python内置了很多内置函数、类方法属性及各种模块。当我们想要当我们想要了解某种类型有哪些属性方法以及每种方法该怎么使用时，我们可以使用dir()函数和help()函数在python ide交互式模式下获得我们想要的信息。
dir()
dir()用来查询一个类或者对象所有属性，比如：

>>> dir(list)
help()
help()函数帮助我们了解模块、类型、对象、方法、属性的详细信息

1.帮助查看类型详细信息，包含类的创建方式、属性、方法

>>> help(list)

2.帮助查看方法的详细使用信息（使用时要注意输入完整路径，使用模块帮助时，需要先导入模块）

>>> from selenium.webdriver.common.by import By
>>> help(By)

获取帮助方法：print(help(set)) #IDLE

{‘one’:1} dict字典 key不可重复 key=》value
[1,2]list 列表可以重复
(1,) tuple 有序的列表元组可重复不可改变若包含可变的list 则其中的list可变。
{1,2,2} set 集合是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
python中集合set主要利用其唯一性去重，及并集|、交集&等操作，但不可以直接通过下标进行访问，必须访问时可以将其转换成list再访问

x={1,2,5}
y=list(x)
a=y[1]
a=x[1]  #'set' object is not subscriptable

创建格式：

parame = {value01,value02,...}
或者
set(value)

set1=set([1,2,3,4])
set2=set(['A','B','D','C'])
set3=set(['A','C', 'B', 'D'])
set4=set(['A','B','D','C','B'])
set5=set('E')
#set6=set('E','A')
#错误提示TypeError: set expected at most 1 arguments, got 2------所以set6不合理
set7=set('hello')
set8=set(['A','B','D','C','B'])

单行字符串

'hello' "hello"

多行字符串

'''hello
	     WORLD'''

去掉转义字符串

 r'hello \n world'

周末8小时python

单元测试phpunit

集合是指包含一组元素的数据结构，我们已经介绍的包括：
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set（[1,2]） //有序集合转无序集合
3. 无序集合并且具有 key-value 对：dict

而迭代是一个动词，它指的是一种操作，在Python中，就是 for 循环。

迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心迭代结果，根本不关心迭代内部是如何实现的。

生成列表

1[x * x for x in range(1, 11)]
2>>> L = []
for x in range(1, 11):
    L.append(x * x)

 #使用for循环的迭代不仅可以迭代普通的list，还可以迭代dict。
 d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
 tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
 #条件过滤
 #列表生成式的 for 循环后面还可以加上 if 判断。
 >>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
#多层表达式
#for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。
#对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：

>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

python中返回函数
返回函数可以把一些计算延迟执行。

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

python中闭包

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

python中匿名函数

高阶函数可以接收函数做参数，有些时候，我们不需要显式地定义函数，直接传入匿名函数更方便。

python中 @property

装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用：

这种行为称为多态。也就是说，方法调用将作用在 x 的实际类型上

python中闭包

在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问：

内置装饰器

Python中，常见的类装饰器包括：@staticmathod、@classmethod和@property

@staticmethod：类的静态方法，跟成员方法的区别是没有self参数，并且可以在类不进行实例化的情况下调用。
@classmethod：跟成员方法的区别是接收的第一个参数不是self，而是cls（当前类的具体类型）
@property：表示可以直接通过类实例直接访问的信息

总结介绍Python的一组高级特性，包括：列表推导式、迭代器和生成器、装饰器。

*args **kwargs

直接内部定义的为类属性
直接调用的为实例属性
实例中类属性和实例属性重名，优先获得实例属性**

类方法 @classmethod 标记 绑定到类上而非实例参数cls 是类本身（类方法只能调用类属性无法获得实例属性只能获得类的引用即传入的参数）

实例方法 self，类中定义

多重继承

构造函数是__init__而非 int

获取对象信息
type() 函数获取变量类型
dir()函数获取变量所有的属性。实例方法也是特殊的属性。

_call_（self，f）允许一个实例可以像一个函数一样可调用。f（f）
p（ss）无法判断p是一个函数还是一个类实例

_slots_ 限制类的实例允许添加的属性,是一个tuple元组

+pyhon常用模块和包（系统自带和第三方）

1.自带的包
sys os path json & pickle random（随机值） time 和 datetime re模块（正则）
2.科学计算
numpy pandas
爬虫 scrapy request beautifulsoup
图像处理相关
自然语言处理
数据库驱动pymysql redis
Web框架 djando
GUI 图形界面
3.python 编写web服务。打包

os 模块是与操作系统交互的一个接口

函数式编程
面向对象编程
继承封装多态
装饰器。
类方法实例方法
类属性实例属性
魔术方法
私有属性和方法 __开头

测试文件二：

import numpy as np
import pandas as pa
# 常用模块
import time,datetime,os,random,sys,json,pickle,hashlib

x=np.arange(1,100)
print(x)
np.save('a',x)
y=np.load('a.npy')

z=np.sin(x)
np.savez('b',x,z)
y=np.load('b.npz')

# numpy　　在深度学习中，我们保存了训练集，验证集，测试集，还包括它们的标签，用这个方式存储起来，要加载什么有什么，文件数量大大减少，也不会到处改文件名。
print(y)
print(y.keys())
print(y['arr_0'])

np.savetxt('t.txt',x)

file='aa.csv'
data=pa.read_csv(file,header=0)

np.save('aa',data.values)

print(data.values)
# Pandas概述
# Pandas是Python的一个数据分析包，该工具为解决数据分析任务而创建。
# Pandas纳入大量库和标准数据模型，提供高效的操作数据集所需的工具。
# Pandas提供大量能使我们快速便捷地处理数据的函数和方法。
# Pandas是字典形式，基于NumPy创建，让NumPy为中心的应用变得更加简单。
#
# 作者：谓之小一
# 链接：<a href='https://www.jianshu.com/p/218baa41bab9'>https://www.jianshu.com/p/218baa41bab9</a>
# 来源：简书
# 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
# pandas可以读取与存取像csv、excel、json、html、pickle等格式的资料，详细说明请看官方资料
p=pa.Series([1,3,4,3,5,'xx'])
print(p)


# 包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来
# 2、创建包的目的不是为了运行， 而是被导入使用， 记住，包只是模块的一种形式而已，包的本质就是一种模块
# 在python中， 模块一般分为四个通用类别
#
#
# 1使用python编写.py 文件
#
# 2、已被编译为共享库或DLL 的c 或c++扩展
#
# 3把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
#
# 4、使用c编写并链接到python解释器的内置模块


# 编写好的一个python文件 可以有两种途径：
#
# 一：脚本，一个文件就是整个程序，用来被执行
# 二 ：模块，文件中存放着一堆功能，用来呗导入使用
#
#
# #python为我们内置了全局变量__name__，
#     当文件被当做脚本执行时：__name__ 等于'__main__'
#     当文件被当做模块导入时：__name__等于模块名
#
#
# #作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
#     if __name__ == '__main__':

# 模块的搜索路径
# 模块的查找顺序：内存中已经加载的模块-->内置模块---->sys.path路径中包含的模块

print(time.time())
print(time.ctime())
print(time.asctime())
# print(datetime.time.strftime())
# print(datetime.date.ctime())

# os 模块是与操作系统交互的一个接口

# os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
# os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
# os.curdir  返回当前目录: ('.')
# os.pardir  获取当前目录的父目录字符串名：('..')
# os.makedirs('dirname1/dirname2')    可生成多层递归目录
# os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
# os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
# os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
# os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
# os.remove()  删除一个文件
# os.rename("oldname","newname")  重命名文件/目录
# os.stat('path/filename')  获取文件/目录信息
# os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
# os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
# os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
# os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
# os.system("bash command")  运行shell命令，直接显示
# os.environ  获取系统环境变量
# os.path.abspath(path)  返回path规范化的绝对路径
# os.path.split(path)  将path分割成目录和文件名二元组返回
# os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
# os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
# os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
# os.path.isabs(path)  如果path是绝对路径，返回True
# os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
# os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
# os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
# os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
# os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
# os.path.getsize(path) 返回path的大小

stus={'xiaojun':'123456','xiaohei':'7891','abc':'11111'}
#先把字典转成json
res2=json.dumps(stus)
print(res2)#打印字符串
print(type(res2))#打印res2类型
print(type(stus))#打印res2类型
# 不管是dump还是load，带s的都是和字符串相关的，不带s的都是和文件相关的。
# 区别
#
# loads()传的是字符串，而load()传的是文件对象
# 使用loads()时需要先读文件再使用，而load()则不用
# dumps\dump中使用参数indent，为字符串换行+缩进：
with open('stus.json','w',encoding='utf-8') as f:
    f.write(res2)

# file=open('stus2.json','w',encoding='utf-8')
# json.dump(stus,file)

file=open('stus2.json','r',encoding='utf-8')
print(json.load(file))
print(json.loads(res2))

print(time.time())
print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

print(datetime.datetime.fromtimestamp(time.time()))
# print()

# 其实在Python3中range()函数返回的对象很像一个列表，但是它确实不是一个列表，它只是在迭代的情况下返回指定索引的值，它并不会在内存中产生一个列表对象，官方解释说这样做是为了节约内存空间。通常我们称这种对象是可迭代的，或者是可迭代对象。
#
# 这里就要引入另外一个叫迭代器的概念，迭代器可以从一个可迭代对象中连续获取指定索引的值，直到索引结束。比如list()函数，所以在上面的例子中，我们可以用list()这个迭代器将range()函数返回的对象变成一个列表。
#
# 由此可以看出：range()函数返回的是一个可迭代对象（类型是对象），而不是列表类型；list() 函数是对象迭代器，把对象转为一个列表，返回的变量类型为列表
a=range(5,10)
for i in a:
    print(i)

print(list(a))

# Python中的random模块用于生成随机数
a=random.random()
a=random.uniform(1,100)
a=random.randint(1,100)
a=random.randrange(100,1000,5)
# 从指定范围内，按指定基数递增的集合中 获取一个随机数。
# 用于将一个列表中的元素打乱,即将列表内的元素随机排列。
x=['A' , 'B', 'C', 'D', 'E' ]
random.shuffle(x)
a=random.choice([1,'23',[4,5]])
print(a)
print(x)

cc=hash('xx')

pwd="alex12345"

m=hashlib.md5()
m.update("一行白鹭上青天".encode("utf-8"))
m.update(pwd.encode("utf-8"))

print(m.hexdigest())



print(cc)


#一对一的匹配
print('hello'.replace('ll','cc'))
print('hello'.find('pattern'))
#正则匹配
import re
#\w与\W
print(re.findall('\w','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']
print(re.findall('\W','hello egon 123')) #[' ', ' ']

测试文件一

def first(*args, **kwargs):
    print(args)
    print(kwargs)


first(1, 2, 3, a=1, b=5)


def pa():
    pass


"""使用高阶函数 返回函数"""


def log(f):
    print('add a log')
    f()


def f():
    print('exec f function')


print(f.__name__)
log(f)
f()


# 使用装饰器
def log_decoration(f):
    def log():
        print('add a decoration log')
        f()

    return log


@log_decoration
def f():
    print('exec f function')


print(f.__name__)

f()


# 使用装饰器 装饰带参数的方法
def log_decoration(f):
    def log(*args, **kwargs):
        print('add a decoration log')
        f(*args, **kwargs)

    return log


@log_decoration
def f(*args, **kwargs):
    print('exec f function')
    print(args)


f('xwsh', 2, 2, )
print(f.__name__)


# 使用装饰器本身带参数  装饰带参数的方法 两层装饰器
def log(msg):
    def log_decoration(f):
        def log(*args, **kwargs):
            print('[%s] %s()...' % (msg, f.__name__))
            print('add a decoration log')
            f(*args, **kwargs)

        return log

    return log_decoration


f('xwsh', 2, 2, )


@log('DEBUG')
def f(*args, **kwargs):
    print('exec f function')
    print(args)


print(f.__name__)


@log('info')
def f1(*args, **kwargs):
    print('exec f function')
    print(args)


f1('xwsh', 2, 2, )
print(f1.__name__)


class student(object):

    # def __init__(self, name, score):
    #     self.__name = name
    #     self.score = score
    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name


# __开头 私有属性

s = student()
s.name = 'xwsh'
print(s.name)

# lambda用来定义一个函数
#
# 普通函数:
#
# def multiply(x, y):
#     return x * y
# 使用lambda重写以上函数:
#
# multiply = lambda x, y: x * y
# lambda函数由三个部分组成:
#
# 1.  lambda 关键字
#
# 2. 用 , 分割的参数,就是普通函数里的参数,后面跟一个 ：
#
# 3. 函数体,就是普通函数里的函数体
t1 = lambda x, y: x ** y
print(t1(2, 4))

# 列表推导式
g = [x * x for x in range(10)]
temp = iter(g)
print(next(temp))
print(next(temp))
print(next(temp))
# 　1.列表推导式比较耗内存,一次性加载,生成器表达式几乎不占用内存,使用的时候才分配和使用内存;
#
# 　　　　2.得到的值不一样,列表推导式得到的是一个列表,生成器表达式获取的是一个生成器.
# 生成器表达式
g = (x * x for x in range(10))
for i in g:
    print(i)


# 总结:
#
# 　　　　推导式有列表推导式,字典推导式,集合推导式,没有元组推导式
#
# 　　　　生成器表达式:(结果 for 变量 in 可迭代对象 if 条件筛选)
#
# 　　　　生成器表达式可以直接获取到生成器对象,生成器对象可以直接进行for循环,生成器具有惰性机制.

def func():
    print(11)
    yield 22


a = func()
print(a)
# print(list(a))
# # print(a.__next__())
for i in a:
    print(i)

g = func()  # 生成器g
g1 = (i for i in g)  # 生成器g1.但是g1的数据来源于g
g2 = (i for i in g1)  # 生成器g2.来源g1

print(list(g))  # 获取g中的数据.这时func()才会被执行. 打印111.获取到222.g完毕.
print(list(g1))  # 获取g1中的数据.g1的数据来源是g. 但是g已经取完了. g1也就没有数据了
print(list(g2))  # 和g1同理

# 把字典中的key和value互换
dic = {'a': 1, 'b': '2'}
new_dic = {dic[key]: key for key in dic}
print(new_dic)


def eat():
    print('我要吃什么')
    a = yield '馒头'
    print('a', a)
    b = yield '大饼'
    print('b', b)
    c = yield '韭菜盒子'
    print('c', c)
    yield 'GAME OVER'


gen = eat()  # 获取生成器
ret1 = gen.__next__()
print(ret1)
ret2 = gen.send('胡辣汤')
print(ret2)
ret3 = gen.send('狗粮')
print(ret3)
ret4 = gen.send('猫粮')
print(ret4)


# 　　send和__next__()区别:
#
# 　　　　1.send和next()都是让生成器向下走一次
#
# 　　　　2.send可以给上一个yield的位置传值,不能给最后一个yield传值,在第一次执行生成器代码的时候不能使用send()

def msg():
    """

    :return:
    """
    pass


print(msg)
print(msg.__doc__)


# help(msg())

class Person():
    age = 18
    # __slots__ = ('name', 'sex', 'ff')
    def __init__(self, name):
        # super(Person, self).__init__()
        self.name = name

    def get_after_age(self):
        return  self.age+10

class Studen(Person):

    __slots__ = ('name','sex','ff')
    def __init__(self,name,sex):
        super(Studen,self).__init__(name)
        self.sex=sex

    @classmethod
    def cls_func(cls):
        return cls.age
    @property
    def score(self):
        return self.__score
    @score.setter
    def score(self,score):
        if score>100:
            raise ValueError('数据错误')
        else:
            self.__score=score
    # 实例变成str时调用
    def __str__(self):
        return 'new student'
    def __len__(self):
        return 2;


    __repr__= __str__

    pass



s1=Studen('xwsh','男')

s1.newss='ddd'
print(s1.newss)


print(s1.name)
print(s1.age)
print(s1.sex)
print(s1.get_after_age())
print(s1.cls_func())

print(isinstance(s1,Person))

print(Person.age)
p1 = Person('xwsh')

print(p1.name)
print(p1.age)
p1.age = 19
print(p1.age)
print(Person.age)
#python 为动态语言 参数X 可以是任何类型 只要存在方法就可以调用

i=[1,2,3]

# #获取对象信息
# type() 函数获取变量类型
# dir()函数获取变量所有的属性。实例方法也是特殊的属性。
print(type(i))
print(type(s1))
print(type(p1))
print(dir(i))



print(getattr(s1,'name'))
setattr(s1,'name','许卫帅')
print(getattr(s1,'name'))

print(i.__sizeof__())
print(__name__)
print(s1)
print(Studen)

# 内建函数
# 1. locals()返回当前作用域中的变量字典
# 2. globals当前模块全局变量的字典
print(locals().keys())
print(globals())

print(s1.__dict__)
print(s1.__class__)
print(s1.__module__)
print(s1.__sizeof__())
print(len(s1))

s1.score=90
print(s1.score)
s1.name='xx'
s1.ff='jj'

print(s1.ff)

print(type(s1))
print(dir(s1))
print(s1.__slots__)


class Worker():
    __slots__ = ('name')
    pass

w=Worker()
w.name='xwsh'
# w.age=14
# print(w.name,w.age)

# 1. 如果模块是被导入，__name__的值为模块名字
# 2. 如果模块是被直接执行，__name__的值为’__main__’
# __name__是一个变量。前后加了爽下划线是因为是因为这是系统定义的名字。普通变量不要使用此方式命名变量