Python基础知识查漏补缺

根据空行来分隔字符串 str.split('\n\n')

通过切片实现列表翻转:a = [1,2,3,4,5]   a[ -1: : -1 ]  即可实现列表翻转,从-1开始直到结束,步长为-1

1.三目运算符:a=1 if b>0 else 2


2.数据类型之set:无序且不允许重复的集合。

    LIST=[1,2,3,1,2,3]

    s = set(LIST)

    s的值为{1,2,3}


3.Python函数如果不写return,默认返回None


4.   a**b为a的b次方         a//b  地板除法,返回商的整数部分


5. 匿名函数: lambda x:x+2   意思是定义了一个匿名函数,参数是x,返回值是x+2

   匿名函数配合三目运算符:   lambda  x:x+100 if x%2==1 else x   如果x为奇数,则返回x+100,如果x为偶数,则返回x


6.一些内置函数:

abs()  返回绝对值

all()  传入多个对象,如果所有对象都为真,则返回True,只要有一个为假就返回False。除了0、None、空值(空字典,空元组,空字符串,空列表),其他都为真。

any()  与all相似,不过any只要有一个为真,就返回True,全部为假才返回False

ascii()  找到对象中的__repr__方法,获取其返回值

bin() 二进制  0b

oct()  八进制  0o

int()  十进制    int('0b11',base=2)  二进制转十进制

hex() 十六进制  0x

bool()  把一个对象转化成bool值,除了0、None、空值(空字典,空元组,空字符串,空列表),其他都为真。

bytes()将一个对象变成字节数组

Bytes 对象是由单个字节作为基本元素(8位,取值范围 0-255)组成的序列,为不可变对象。

Bytes 对象只负责以二进制字节序列的形式记录所需记录的对象,至于该对象到底表示什么(比如到底是什么字符)则由相应的编码格式解码所决定。我们可以通过调用 bytes() 类(没错,它是类,不是函数)生成 bytes 实例,其值形式为 b'xxxxx',其中 'xxxxx' 为一至多个转义的十六进制字符串(单个 x 的形式为:\xHH,其中 \x 为小写的十六进制转义字符,HH 为二位十六进制数)组成的序列,每个十六进制数代表一个字节(八位二进制数,取值范围 0-255),对于同一个字符串如果采用不同的编码方式生成 bytes 对象,就会形成不同的值:

b = bytes('我',encoding='utf-8')

c = bytes('我',encoding='gb2312')



chr()  返回数字对应ASCII表中的字母,例如chr(66) = B

ord()  返回字符对应ASCII表中的数字,例如ord('a') = 97

callable(obj)  判断obj是否为可执行对象,如果是返回True,否则返回False( 目前所知函数和类返回True )

compile()  编译py代码

divmod(10,3)  返回( 3,1 )    返回一个元组,第一个值为商,第二个值为余数。在进行分页的时候会用到

enumerate(obj)  传入一个可迭代对象,返回一个enumerate对象,可以迭代这个对象来获得原可迭代对象的索引和值

EXP:

a=[1,3,4,6,1]
for index,value in enumerate(a):
    print(index,value)

如果是

for i in enumerate(a):
    print(i)

则返回一个个元组,( index , value )


eval()  通过eval可以执行一个字符串形式的表达式,例如:

a=['1+3','1-3','1*3','1/3','1+3*2']
b=[]
for i in range(5):
    b.append(eval(a[i]))
    print(i)

eval() 第二个参数可以接收一个字典,例如:

b = eval('a+1',{'a':99})
print(b)
b的值为100

exec( string )用来执行string的代码

filter(function or none,可迭代对象),返回值为一个filter对象,需要利用list()将其转换成一个列表。

当第一参数为none时,filter会返回可迭代对象中所有为True的项。

当第一参数为一个函数时,将可迭代对象中每个值放入函数中运算,再进行过滤,返回所有为True的值。

a = list(filter(lambda x:x%2,[1,2,3,4,5,6,7,8]))
print(a)

def f(x):
    return True

a=list(filter(f,[0,4,5,7,8,'eqwe']))
print(a)
  本来0不应该被返回,但是函数f的返回值恒为True,所以0也被返回了

map(function,可迭代对象)   将可迭代对象作为function中的参数进行运算,并返回运算结果,返回值为一个map对象,需要用list()转换成列表。

a = list(map(lambda x:x%2,[1,2,3,4,5,6,7,8]))
print(a)

可以用for循环来迭代filter和map对象

globals()  获取所有全局变量

locals()  获取所有局部变量

id(obj)  查看对象的内存地址

isinstance(obj,class)  判断某个对象是否为某个类创建的

hash(obj) 本函数返回对象的哈希值。返回的哈希值是使用一个整数表示,通常使用在字典里,以便实现快速查询键值。参数object输入是数字类型时,是根据数值来计算的,比如1和1.0计算出来是一样的哈希值,因此说这个函数是不区分不同的数值类型。
hash(1)=1      hash(1.0)=1   hash('abc')=700737775

pow(2,10)  用来运算指数的,2的十次方

round(float or int)  四舍五入

zip(obj,obj)

list.sort()  对列表进行排序,但不会生成新的对象,直接把排序结果返回给list

new_list = sorted(list)  同样是排序,但是会生成一个新的对象    

python内置的sorted方法只支持同类型排序,例如 [ '2', '1' , '3' ],[ 'b', 'c', 'a' ]

对于这种字符串:[ '123' , '23' , 'q' ,'qw' , 'r' ,'张' ],sorted方法是按每个字符来排序,数字在前,字母在后,中文最后。

对于'123'和 '23' 因为第一个字符1比2小,所以'123'在前。'qw'第一个字符'q'在'r'前,所以'qw'在'r'前。

对于字母类字符,比较的是其ASCII码值的大小,所以A在a前


Python之文件操作

一、打开文件

file = open('文件路径', '模式')

打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作。

打开文件的模式有:

  • r ,只读模式【默认】
  • w,只写模式【不可读;不存在则创建;存在则清空内容;】
  • x, 只写模式【不可读;不存在则创建,存在则报错】
  • a, 追加模式【可读;   不存在则创建;存在则只追加内容;】

"+" 表示可以同时读写某个文件

  • r+, 读写【可读,可写】
  • w+,写读【可读,可写】
  • x+ ,写读【可读,可写】
  • a+, 写读【可读,可写】

 "b"表示以字节的方式操作

  • rb  或 r+b
  • wb 或 w+b
  • xb 或 w+b
  • ab 或 a+b

 注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型

二、操作

class TextIOWrapper(_TextIOBase):
    """
    Character and line based layer over a BufferedIOBase object, buffer.
    
    encoding gives the name of the encoding that the stream will be
    decoded or encoded with. It defaults to locale.getpreferredencoding(False).
    
    errors determines the strictness of encoding and decoding (see
    help(codecs.Codec) or the documentation for codecs.register) and
    defaults to "strict".
    
    newline controls how line endings are handled. It can be None, '',
    '\n', '\r', and '\r\n'.  It works as follows:
    
    * On input, if newline is None, universal newlines mode is
      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
      these are translated into '\n' before being returned to the
      caller. If it is '', universal newline mode is enabled, but line
      endings are returned to the caller untranslated. If it has any of
      the other legal values, input lines are only terminated by the given
      string, and the line ending is returned to the caller untranslated.
    
    * On output, if newline is None, any '\n' characters written are
      translated to the system default line separator, os.linesep. If
      newline is '' or '\n', no translation takes place. If newline is any
      of the other legal values, any '\n' characters written are translated
      to the given string.
    
    If line_buffering is True, a call to flush is implied when a call to
    write contains a newline character.
    """
    def close(self, *args, **kwargs): # real signature unknown
        关闭文件
        pass

    def fileno(self, *args, **kwargs): # real signature unknown
        文件描述符  
        pass

    def flush(self, *args, **kwargs): # real signature unknown
        刷新文件内部缓冲区
        pass
    # 一个写入文件的进程结束后,才会将数据写到文件中,否则数据是存在内存中的。flush()
    # 可以将内存中的数据存到硬盘中
   
    def isatty(self, *args, **kwargs): # real signature unknown
        判断文件是否是同意tty设备
        pass

    def read(self, *args, **kwargs): # real signature unknown
        可以指定读取的字符数,例如f.read(3) 只读取三个字符
        pass

    def readable(self, *args, **kwargs): # real signature unknown
        是否可读
        pass

    def readline(self, *args, **kwargs): # real signature unknown
        仅读取一行数据
        pass

    def seek(self, *args, **kwargs): # real signature unknown
        指定文件中指针位置
        pass

    def seekable(self, *args, **kwargs): # real signature unknown
        指针是否可操作
        pass

    def tell(self, *args, **kwargs): # real signature unknown
        获取指针位置
        pass

    def truncate(self, *args, **kwargs): # real signature unknown
        截断数据,仅保留指针之前数据
        pass

    def writable(self, *args, **kwargs): # real signature unknown
        是否可写
        pass

    def write(self, *args, **kwargs): # real signature unknown
        写内容
        pass

    def __getstate__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __next__(self, *args, **kwargs): # real signature unknown
        """ Implement next(self). """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

三、管理上下文

为了避免打开文件后忘记关闭,可以通过管理上下文,即:

with open('log','r') as f:
        
    ...
如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。

在Python 2.7 及以后,with又支持同时对多个文件的上下文进行管理,即:

with open('log1') as obj1, open('log2') as obj2:
    pass

四、文件指针

对于 ‘r+’ 模式:文件指针默认指向0,在进行读取操作时,将文件内容读取完毕后,文件指针指向文件末尾。如果对文件写入,写入后文件指针会指向写完后的位置,所以刚写入的信息不能直接读出,除非手动修改文件指针的位置。如果直接对文件进行写入,则是从0位置开始写入。


对于‘a’和‘a+’ 模式:由于是追加模式,所以文件指针默认在文件的末尾。


五、

复制一个超大文件,如果把整个文件读取到内存然后再复制显然是非常不可取的,我们应该一行行的读取然后复制到另一个文件中

with open('f1.txt', 'r') as f1, open('f2.txt', 'w') as f2:
    for line in f1:
        f2.write(line)

在close掉文件后,文件指针归零。如果想要保存文件指针的位置,可以到保存到硬盘上,下次再打开该文件时,使用f.seek()命令,将文件指针指向上次的位置,进行后续操作。

7、函数传值问题


首先还是应该科普下函数参数传递机制传值和传引用是什么意思?

   函数参数传递机制问题在本质上是调用函数(过程)和被调用函数(过程)在调用发生时进行通信的方法问题。基本的参数传递机制有两种:值传递和引用传递。

  值传递(passl-by-value)过程中,被调函数的形式参数作为被调函数的局部变量处理,即在堆栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。

  引用传递(pass-by-reference)过程中,被调函数的形式参数虽然也作为局部变量在堆栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过堆栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

      在python中实际又是怎么样的呢?下面看一个例子

def func(c):
    print('将实参a传入函数后,声明的局部变量c的地址%s' % id(c))
    print('begin test')
    c = c+2
    print('进行运算c=c+2后c的地址%s' % id(c))
    print('test over')
    return c

a = 1

if __name__ == '__main__':
    print('初始a的地址为%s' % id(a))
    n = func(a)
    print('运算后a的地址为 %s' % id(a))
    print('运算结果n的地址为%s' % id(n))
    print(a)
    print(n)

运算结果:

分析:

初始 a-->50659377,将a传递进函数func实际传递的是a的引用,即a的地址。所以形式参数c-->50659377,在进行了操作c=c+2后,

按照道理来说c-->506593808并且a-->506593808,因为引用传递的是地址,对c进行的任何操作应该会影响到a才对,但是在Python

中,int和string是不可变类型,因此a的值并不会改变,而是重新开辟一片内存区域,用于存放c+2的值。

总结:

1. 在Python中,对于不可变对象,调用自身的任意方法,并不会改变对象自身的内容,这些方法会创建新的对象并返回,保证了不

可变对象本身是永远不可变的。

2. 对于可变对象,对于其的操作并不会产生新的对象,而是修改他的值

3. python不允许程序员选择采用传值还是传引用。Python参数传递采用的肯定是“传对象引用”的方式。这种方式相当于传值和传引用

的一种综合。如果函数收到的是一个可变对象(比如字典或者列表)的引用,就能修改对象的原始值相当于通过“传引用”来传递对

象。如果函数收到的是一个不可变对象(比如数字、字符或者元组)的引用,就不能直接修改原始对象相当于通过“传值'来传递对

象。

isinstance(obj, cls)

 检查是否obj是否是类 cls 的对象

class Foo(object):
    pass
 
obj = Foo()
 
isinstance(obj, Foo)

issubclass(sub, super)

检查sub类是否是 super 类的派生类

class Foo(object):
    pass
 
class Bar(Foo):
    pass
 
issubclass(Bar, Foo)



一、异常处理:

  try:
	num = input('请输入一个数字')
	result = int(num)
  except Exceptions as e:
	print('输入错误')

二、异常种类:

AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x
IOError 输入/输出异常;基本上是无法打开文件
ImportError 无法引入模块或包;基本上是路径问题或名称错误
IndentationError 语法错误(的子类) ;代码没有正确对齐
IndexError 下标索引超出序列边界,比如当x只有三个元素,却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法,代码不能编译(个人认为这是语法错误,写错了)
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量,基本上是由于另有一个同名的全局变量,
导致你以为正在访问它
ValueError 传入一个调用者不期望的值,即使值的类型是正确的

对于上述实例,异常类只能用来处理指定的异常情况,如果非指定异常则无法处理。

# 未捕获到异常,程序直接报错
 
s1 = 'hello'
try:
    int(s1)
except IndexError,e:
    print e

所以,写程序时需要考虑到try代码块中可能出现的任意异常,可以这样写:

s1 = 'hello'
try:
    int(s1)
except IndexError,e:
    print e
except KeyError,e:
    print e
except ValueError,e:
    print e

万能异常 在python的异常中,有一个万能异常:Exception,他可以捕获任意异常,即:

s1 = 'hello'
try:
    int(s1)
except Exception,e:
    print e

接下来你可能要问了,既然有这个万能异常,其他异常是不是就可以忽略了!

答:当然不是,对于特殊处理或提醒的异常需要先定义,最后定义Exception来确保程序正常运行。

s1 = 'hello'
try:
    int(s1)
except KeyError,e:
    print '键错误'
except IndexError,e:
    print '索引错误'
except Exception, e:
    print '错误'

三、异常其他结构

try:
    # 主代码块
    pass
except KeyError,e:
    # 异常时,执行该块
    pass
else:
    # 主代码块执行完,执行该块
    pass
finally:
    # 无论异常与否,最终执行该块
    pass

四、主动触发异常

try:
    raise Exception('错误了。。。')
except Exception,e:
    print e

五、自定义异常

class WupeiqiException(Exception):
 
    def __init__(self, msg):
        self.message = msg
 
    def __str__(self):
        return self.message
 
try:
    raise WupeiqiException('我的异常')
except WupeiqiException,e:
    print e

六、断言

# assert 条件
 
assert 1 == 1
 
assert 1 == 2

第一条命令

flask.__version__

返回库的版本

第二条命令

flask.__file__

返回库所在的文件夹




阅读更多
版权声明:转载请注明原文地址 https://blog.csdn.net/qq_29113041/article/details/78205657
个人分类: Python
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭