python基础知识总结

1.python变量

          1.1特点：

          无需事先声明变量名及类型，直接赋值即可创建各种类型的变量。

          python变量的类型可以随时变化。

        python采用基于值得内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只有一份，多个变量指向同一块内存地址。

          1.2变量名

          变量名必须以字母或下划线开头。不能有空格及标点符号（括号/引号/逗号/斜线/反斜线/冒号/句号/问号等）。不能以关键字作为变量名。变量名区分大小写。

          1.3数字

           不可变对象。即修改变量值的时候并不是真的修改变量的值，而是先把值存放到内存中然后修改变量使其指向新的内存地址。

          1.4字符串

          不可变序列。

          1.5运算符与表达式

          

           Python算术运算符

              以下假设变量： a=10，b=20：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

             

Python比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

                    1.6基本输入输出

                使用input()来接收用户的键盘输入，例如 x=input(‘提示：’)

                使用print()输出。

              例题：编写程序，用户输入一个三位以上的整数，输出其百位上的数字。例如用户输入1234，则程序输出12（使用整除运算）        

a=input('请输入一个三位数以上的整数')
a=int(a)
b=a//100
print(b)

2.模块的导入与使用

       2.1import 模块名 [as 别名]      如import numpy as np

       2.2from 模块名 import 对象名[as 别名] 如 from math import sin

3.python序列

   3.1列表

         可变序列。所有元素放在一对“[]”中，相邻元素使用逗号分隔。当列表增加或删除元素时，列表对象自动进行内存的扩展和收缩，从而保证元素之间没有缝隙。同一个列表中元素的类型可以不相同，可以同时包含整数，实数，字符串等基本类型，也可以是列表，元组，字典，集合及其他自定义类型的对象。

         range()函数   接收三个参数  第一个参数为起始值（默认为0），第二个参数表示终止值（结果中不包括这个值），第三个参数表示步长（默认为1）。返回一个range可迭代对象。

           加号连接运算符，星号 * 是重复操作 + 是列表。

         增 

               append()  在列表尾部添加元素，速度较快。

                   +运算符。

                   extend() 将另一个迭代对象的所有元素添加至该列表对象尾部。

                   insert() 将元素添加至列表的指定位置。

         删    

               del()删除指定位置上的元素，也可删除整个列表。  del a_list[1]

                  pop() 删除并返回指定（默认为最后一个）位置上的元素，如果索引超出范围则抛出异常。

                  remove() 删除首次出现的指定元素，若不存在，抛出异常。

        查

               index（value，[start，[stop]]）返回元素首次出现的下标

               count() 返回元素在列表中出现的次数

          列表推导式

   3.2元组（）

        不可变序列。

        tuple()函数可以看作是在冻结列表使其不可变，而list()函数是在融化元组使其可变。

        序列解包

        生成器推导式

   3.3字典{}  

        键值 无序可变序列  不支持下标访问

   3.4集合{}

         无序 元素不允许重复，集合中每个元素都是唯一的。

4.选择和循环

      【例1】用户输入若干个成绩，求所有成绩的总和。每输入一个成绩后询问是否继续输入下一个成绩，回答yes就继续输入下一个成绩，回答no就停止输入成绩。

endflag='yes'
s=0
while endflag.lower()=='yes'
    x=input("请输入一个正整数：")
    x=eval(x)
    if isinstance(x,int) and 0<=x<=100:
        s=s+x
    else:
        print('不是数字或不符合要求')
        endflag=raw_input('继续输入?(yes or no)')
print('整数之和=，'s)

【例二】计算1～100的和

a=0
for i in range(1,101)
    a=a+i
print(a)

【例三】输出序列中的元素

alist=['a','b','mpilgrim','z','example']
for i,v in enumerate(a_list):
    print('列表的第'，i+1，'个元素是：'，v)

【例4】求1～100之间能被7整除，但不能同时被5整除的所有整数

 

for i in range(1,101)

    if i//7==0 and i//5!=0

        print(i)

【例5】求平均分

 

score=[70,90,78,85,97,94,65,80]

s=0

for i in score:

    s+=i

print(s/len(score))

【例6】打印九九乘法表

for i in range(1,10):
    for j in range(1,i+1):

        print(i,'*',j,'=',i*j,'\t',end=' ')

    print()

【例7】求200以内能被17整除的最大正整数

for i in range(200,0,-1):
    if i%17==0:
        print(i)
        break

【例8】生成一个含有20个随机数的列表，要求所有元素不相同，并且元素的值介于1~100之间

import  random
list=[]
while True:
    if len(list)==20:
        break
    n=random.randint(1,100)
    if n not in list:
        list.append(n)
print(list)

【例9】生出一个包含50个随机整数的列表，然后删除其中所有奇数（提示：从后往前删）

import  random
list=[]
while True:
    if len(list)==50:
        break
    n=random.randint(0,100)
    list.append(n)
for i in range(49,0,-1):
    if list[i]%2!=0:
        list.pop(i)
print(list)

【例10】生成一个包含20个随机整数的列表，然后对其中偶数下标的元素进行降序排列，奇数下标的元素不变（提示：使用切片）

import  random
x=[random.randint(0,100) for i in range(20)]
print(x)
y=x[::2]
y.sort(reverse=True)
x[::2]=y
print(x)

【例11】使用两种不同的方法计算100以内所有奇数的和

x=[i for i in range(1,100,2)]
print(sum(x))
print(sum(range(1,100)[::2]))

5.正则表达式

6.函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

参数

以下是调用函数时可使用的正式参数类型：

• 必备参数  
• 关键字参数
• 默认参数
• 不定长参数

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。

匿名函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

7类与对象

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 实例变量：定义在方法中的变量，只作用于当前实例的类。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__private_methods。

8文件操作

1.打开文件： 
fp = open(filename,mode) 
filename是文件名。 
mode是文件的打开方式。默认是r+。主要参数有r–只读，w–新建写，a–追加，(+)–可写，b–二进制方式。常用的有r+ – 读写模式打开，rb+ – 二进制读写模式，wb+ – 二进制格式打开，用于读写，若文件已存在则覆盖，不存在则新建，a+ – 追加写。

2.读取文件 
read(size): 读取size的字节数。size为空时，读取文件所有字节。 
readlines(size):把读取到的值放在列表里存储并返回列表值。size并不是单纯的字节数，匹配到的是只要是大于某一行起始值的都会读出整行。 
readline(size):若当前行的值大于size，则读当size值。若小于，则返回 
当前行。为空则返回整行。 
迭代器：文件本身可以看做一个迭代器，循环操作。像下面这样循环遍历就可以全部读出了。

f = open("foo.txt")
for i in f:
    print (i)

在文件内容比较大时，使用迭代器可以在不消耗大量内存的情况下，对文件进行操作。

3.文件写入 
1.write(str):将字符串写入文件，一般情况下写入可以直接：

write("lily")

二进制模式下写入，需要转换编码格式，可以如下写入：(稍微解释下decode()和encode(),他们是分别进行解码和编码的)

bytes —-decode()—-> str(unicode)—encode()—>bytes

f.write(bytes("lily",'utf-8'))
or 
f.write("lily".encode())

2.writelines(sequence_of_strings):写多行到文件。

4.文件关闭与缓冲 
需要注意的是，下面的代码并不能读出文件内容。因为文件写入后存在一定的缓冲，并没有写到系统磁盘里面，所以不能直接读取。需要关闭后再打开读取。

f = open("foo.txt",'w+')
f.write('111')
# f.close() (如果没有关闭文件，是读取不到的)
# f = open("foo.txt")
fr=f.read()
print (fr)

5.文件指针 

f = open("foo.txt",'r+')
fr=f.read()
f.close()
print (fr)
# fr:0123456789abcdef

f = open("foo.txt",'r+')
fr1=f.read(3)
fr2=f.read(3)
print (fr1)
print (fr2)
# fr1:012
# fr2:345

如上代码，可以知道foo.txt里的内容是“0123456789abcdef”，用read()读出的f1和f2分别是“012”和“345”，可知，用read()读取之后，文件指针的位置也相应地后移。 
文件指针的操作方法： 
tell()：查看文件指针当前的位置。 
seek(offset[,whence]):可以用来移动文件指针。 
offset偏移量； 
whence偏移相对位置，分别有：os.SEEK_SET（相对文件起始位置，也可用“0”表示）；os.SEEK_CUR（相对文件当前位置，也可用“1”表示）；os.SEEK_END（相对文件结尾位置，也可用“2”表示）。 
还是上面的例子：

fr1=f.read(3)
print(fr1)  
#fr1=012 读取三个字节
ft2=f.tell()
print (ft2)
#fr2=3  当前指针所指位置是3
fes=f.seek(2,os.SEEK_SET)
ft3=f.tell()
print (ft3)
#fr3=2   相对起始位置偏移了2个字节，当前指针是2