python学习笔记

基础知识

基础语法

1.标识符
（1）标识符
python中标识符对大小写敏感。
（2）关键字

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

2.注释

#hhh
'''
h
f
a
'''
print('helloworld')

helloworld

3.代码块
（1）使用缩进替代{ }来表示代码块，且同一代码块内缩进一致。
（2）若同一语句要换行，①每一行末尾加\；②加[],(),{}。
（3）同一行语句之间用分号分开。
（4）print输出默认换行，不换行操作如下：

print('a');print('b')
print('a',end='');print('b',end='');

a
b
ab

4.导入模块
在 python 用 import 或者 from…import 来导入相应的模块。
（1）将整个模块(somemodule)导入，格式为： import somemodule
（2）从某个模块中导入某个函数,格式为： from somemodule import somefunction
（3）从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
（4）将某个模块中的全部函数导入，格式为： from somemodule import *

#导入整个模块
import keyword
print(keyword.kwlist)

#只导入模块中的某个函数
from keyword import kwlist
print(kwlist)

基本数据类型

1.
（1）python 中的变量不需要声明。
（2）每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
（3）变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

a1=1
a2=b2=c2=2
a3,b3,c3=1,1.0,'abc'
print(a3,b3,c3)

1 1.0 abc

2.几种基本数据类型
（1）Number类型

a,b,c,d=1,1.11,True,3+4j
print(type(a),type(b),type(c),type(d))

<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

数值运算：
数学函数，运算符

print(5/2)
print(5//2)
print(5%2)
print(5**2)
a=0;b=1
a,b=b,a+b
print(a,b)

2.5
2
1
25
1 1

（2）String类型
①python没有字符类型，一个字符就是长度为1的字符串。
②python字符串不能改变，不能对其索引位置进行赋值。
③索引从左往右依次为0，1，2…；从右往左依次为-1，-2，-3…。
转义字符，字符串运算符，字符串函数

str='abcdefg'
print(str)
print(str[0:-1])
print(str[0])
print(str[-1])
print(str[2:5])
print(str[0:5:2])
print(str[2:])
print(str*2)
print(str+'123')
print("转义：")
print('hello\nworld')
print(r'hello\nworld')
print('我叫%s，今年%d岁。'%('小米',10))

abcdefg
abcdef
a
g
cde
ace
cdefg
abcdefgabcdefg
abcdefg123
转义：
hello
world
hello\nworld
我叫小米，今年10岁。

（3)List类型
①列表中的值可以通过索引改变，索引位置与字符串同。
②列表中的值类型可以不同。
列表函数，方法

li=['abc',1.1,100,'str',True]
lj=[123,'qo']
print(li)
print(li[0]);print(li[-1])
print(lj*2)
print(li+lj)
li[1]='abc'
li[2:4]=[False,99]
print(li)

['abc', 1.1, 100, 'str', True]
abc
True
[123, 'qo', 123, 'qo']
['abc', 1.1, 100, 'str', True, 123, 'qo']
['abc', 'abc', False, 99, True]

（4)Tuple类型
与列表类型不同之处：
①值不可修改。
②小括号包含。
③构造0个或1个元素的元组类型有特殊规则。
元组运算符，函数

tu=('abc',)#当只有1个元素时，后面要加上逗号
tv=()#空元组

（5）Set类型
①基本功能：测试和删除重复元素(成员)。
②可以进行集合运算。
③使用大括号 { } 或者 set() 函数创建集合，但创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合方法

sites={'a','b','c','a','e','c'}
print(sites)#输出集合，重复的元素被自动去掉
#成员测试
if 'c' in sites:
    print('c在集合中')
else:
    print('c不在集合中')
#集合运算
a=set('abracadabra')
b=set('alacazam')
print(a)
print(a-b)#a和b的差集
print(a|b)#a和b的并集
print(a&b)#a和b的交集
print(a^b)#a和b中不同时存在的元素

{'e', 'b', 'a', 'c'}
c在集合中
{'r', 'c', 'd', 'b', 'a'}
{'d', 'r', 'b'}
{'m', 'z', 'r', 'c', 'l', 'd', 'b', 'a'}
{'a', 'c'}
{'r', 'm', 'l', 'd', 'z', 'b'}

（6）Dictionary类型
①字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
②键(key)必须使用不可变类型；在同一个字典中，键(key)必须是唯一的。
字典函数，方法

dic1={}
dic1['abc']=1;dic1[2.2]='web'
dic2={'a1':1.1,'b1':2.2,'c1':3.3}
print(dic1['abc'])
print(dic1.values())
print(dic2)
print(dic2.values())
print(dic2.keys())

1
dict_values([1, 'web'])
{'a1': 1.1, 'b1': 2.2, 'c1': 3.3}
dict_values([1.1, 2.2, 3.3])
dict_keys(['a1', 'b1', 'c1'])

数值运算

数学函数，运算符

条件语句

num=int(input('请输入一个数：'))
if num<0:
    print('数小于0')
elif num==0:
    print('数等于0')
elif num>0:
    num=num**2+1
    print('数为%d'%num)
    print('num=',num)

请输入一个数：23
数为530
num= 530

循环语句

有限循环

（1）while

n=0;sum=0
while n<100:
    sum+=n
    n+=1
print(sum)

4950

（2）while…else…

count=0
while count<4:
    print('%d<4'%count)
    count+=1
else:
    print('%d=4'%count)

0<4
1<4
2<4
3<4
4=4

（3）for

l=['a','b',1,2]
for x in l:print(x)

a
b
1
2

（4）for…else…

l=['a','b',1,2]
for x in l:
    if x==1:
        print('找到')
        break
    print('正在查询',x)
else:
    print('不存在')

正在查询 a
正在查询 b
找到

无限循环

无限循环在服务器上客户端的实时请求非常有用。

迭代器&生成器

函数

函数定义及调用

def max(a,b):
    if a>b:
        return a
    else:
        return b
print(max(2,3))

3

def printme(str):
    print(str)
    return
printme('abc')

abc

参数传递

（1）可更改(mutable)与不可更改(immutable)对象
①在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

**不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

**可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

②python 函数的参数传递：

**不可变类型：类似 C++ 的值传递，如 整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a)）内部修改 a 的值，则是新生成来一个 a。

**可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响。

不可变参数传递

def change(a):
    print(id(a))
    a=10
    print(id(a))
    return
a=1
print(id(a))
change(a)

140714940683296
140714940683296
140714940683584

可变参数传递

def changelist(li):
    li.append([1,2,3,4])
    print('函数内：',li)
    return
li=[1,2,3,4]
changelist(li)
print('函数外：',li)

函数内： [1, 2, 3, 4, [1, 2, 3, 4]]
函数外： [1, 2, 3, 4, [1, 2, 3, 4]]

参数一般规则

（1）如果单独出现星号 * 后的参数必须用关键字传入。

（2）加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

（3）加了两个星号 ** 的参数会以字典的形式导入。

（4）函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式；*用来指明函数形参必须使用关键字参数的形式，不能使用指定位置参数。

匿名函数

sum=lambda a,b:a+b
print(sum(10,20))

30

数据结构

栈

stack=[1,2,3]
stack.append(6)
print(stack)
print(stack.pop())
print(stack)

[1, 2, 3, 6]
6
[1, 2, 3]

队列

from collections import deque
queue=deque([1,2,3])
queue.append(6)
print(queue)
print(queue.popleft())
print(queue)

deque([1, 2, 3, 6])
1
deque([2, 3, 6])

文件

f=open("E:/python/file01.txt","w")
f.write("python学习笔记\n在这里\n")
f.close()

f=open("E:/python/file01.txt","r")
str=f.read()
print(str)
f.close()

python学习笔记
在这里

文件

异常处理

异常处理

类

（1）私有属性：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。
（2）在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
（3）私有方法：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。

#类定义
class people:
    #定义基本属性
    name=''
    age=0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight=0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name=n
        self.age=a
        self.__weight=w
    def speak(self):
        print("%s说:我%d岁。"%(self.name,self.age))

# 单继承示例
class student(people):
    grade=''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade=g
    #覆写父类的方法
    def speak(self):
        print("%s说:我%d岁了，我在读%d年级"%(self.name,self.age,self.grade))

#另一个类，多重继承之前的准备
class speaker():
    topic=''
    name=''

    def __init__(self,n,t):
        self.name=n
        self.topic=t
    def speak(self):
        print("我叫%s，我是一个演说家，我演讲的主题是%s"%(self.name,self.topic))

# 多重继承
class sample(speaker,student):
    a=''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

test=sample("Tim",25,80,4,"Python")
test.speak()#方法名同，默认调用的是在括号中排前地父类的方法

我叫Tim，我是一个演说家，我演讲的主题是Python

实例

#阿姆斯特朗数
a=int(input('请输入一个正整数：'))
n=len(str(a))
sum=0
temp=a
while temp>0:
    yu=temp%10
    sum+=yu**n
    temp//=10
if sum==a:
    print('{0}是阿姆斯特朗数'.format(a))
else:
    print('{0}不是阿姆斯特朗数'.format(a))

请输入一个正整数：153
153是阿姆斯特朗数

#递归生成斐波那契数列
def recur_fibo(n):
    if n<=1:
        return n
    else:
        return(recur_fibo(n-1)+recur_fibo(n-2))

n=int(input('输出的斐波那契数列个数：'))
if n<=0:
    print('输入正整数')
else:
    print('斐波那契数列：')
    for i in range(n):
        print(recur_fibo(i),end='\t')
    print()

输出的斐波那契数列个数：13
斐波那契数列：
0	1	1	2	3	5	8	13	21	34	55	89	144