Python学习笔记

基本语法

提示符：>>>
a=input("提示：")输入一个给a，不限类型
print(r"")为原始字符串，可以不用转义字符直接输出
+ 是字符连接
*. 重复输出字符串
例如：

'123' *3
'123123123'

[] 通过索引获取字符串中的字符
例如：

a='llovepy'
a[0]
'l'
a[1]
'l'
a[2]
'o'

[]中的就是下标

a="okay"
a[-1]
'y'
a[-2]
'a'

负数的话就是从右向做访问

[:] 字符串截取

a[0:1]
      
'o'
a[1:3]
      
'ka'
a[0:4]
      
'okay'

包括前面，不包括后面

a[::]
      
'okay'
a[::2]
      
'oa'
a="123456789"
      
a[::2]
      
'13579'
a[::-1]
      
'987654321'
a[::-2]
      
'97531'

in 成员运算符，如果包含返回true
还有not in

format    
以位置的形式 a:0 b:1 c:2

print('{0},{1},{0}'.format('a','b','c'))
a,b,a

以名称的形式 相当于 key和value

print('z:{s},{b}'.format(s=40,b=30))
z:40,30

布尔可以运算，首字母必须大写     True是1False是0

True+3
      
4
False+3
      
3

None表示空

空值算是假值

bool()
      
False
bool( )
      
False
bool(' ')
      
True
bool({})
      
False

python中没有真正意义上的常量，即便是常量他也会发生变化，只是规定了常量需要大写表示

整数池范围[-5,256]

运算符与表达式

+ - * / %
** 指数 10**20 是10的20次方
// 整除 9//2=4，9.0//2.0=4.0 不管是小数还是整数，都会去掉余数

== 比较
!= <> 不等

非与或
not and or

位运算
& | ^ ~ << >>
& 一个为0就是0
| 为1就是1
^ 相同为0，不同为1
~ 1变0，0变1，不同为1
3<<1 乘2的1次方
3>>1 除2的1次方

Python成员运算

in
ont in标识运算符
is    判断id（地址）是是否相等

is not

x is y

4 or 9
4
4 and 9
9

在前面不是0的时候，or以前为主 ，否者以后为主
and以后为主，不管有没有0

列表（list）

列表（list）最常用的Python数据类型，可以存放不同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
list=['中国','美国',1998]
可以使用list(参数)强制转换
a=list()

更新

p=list("python")
      
p
      
['p', 'y', 't', 'h', 'o', 'n']
p[3]="py"
      
p
      
['p', 'y', 't', 'py', 'o', 'n']
p[3:]=[3,4,5,6]
      
p
      
['p', 'y', 't', 3, 4, 5, 6]

冒号后面是全部的内容

删除

['p', 'y', 't', 3, 4, 5, 6]
del p[3]
      
p
      
['p', 'y', 't', 4, 5, 6]
del p[3:]
      
p
      
['p', 'y', 't']
del p[1:3]
      
p
      
['p']

全部删除

del p[:]
      
p

del是语句
remove(参数)是方法

p.remove('h')
      
p
      
['p', 'y', 't', 'o', 'n']

其中的参数是列表中的内容

pop()删除

使用pop()方法删除列表的指定位置的元素，无参时删除最后一个

p=['p', 'y', 'h', 'o', 'n']
p.pop()
      
'n'
p
      
['p', 'y', 'h', 'o']
p.pop(2)
      
'h'

他会返回删除的值

添加列表元素

append()方法在列表末尾添加元素，一次只能添加一个

p.append("python")
      
p
      
['p', 'y', 'o', 1, '2', 'python']
p.append([1,2,3,4])
      
p
      
['p', 'y', 'o', 1, '2', 'python', [1, 2, 3, 4]]
p[6]
      
[1, 2, 3, 4]

extend()一次可以添加多个

p.extend(['a',1,[567]])
      
p
      
['p', 'y', 'o', 1, '2', 'python', [1, 2, 3, 4], 'a', 1, [567]]

p=list((1,2,3,4))
      
p
      
[1, 2, 3, 4]
p.extend("pyhton")
      
p
      
[1, 2, 3, 4, 'p', 'y', 'h', 't', 'o', 'n']
len(p)
      
10
p.append("python")
      
p
      
[1, 2, 3, 4, 'p', 'y', 'h', 't', 'o', 'n', 'python']
len(p)
      
11

insert()方法 在中间插入

p=list("python")
      
p
      
['p', 'y', 't', 'h', 'o', 'n']
p.insert(1,60)
      
p
      
['p', 60, 'y', 't', 'h', 'o', 'n']
p.insert(-1,900)
      
p
      
['p', 60, 'y', 't', 'h', 'o', 900, 'n']

列表长度len(参数)

b=a=[1,2]
      
print(a,b)
      
[1, 2] [1, 2]
b+a
      
[1, 2, 1, 2]
a=a+b
      
a
      
[1, 2, 1, 2]
b
      
[1, 2]

增量赋值

b*3
      
[1, 2, 1, 2, 1, 2]

列表排序

list.sort()
a.sort()
      
a
      
[1, 1, 2, 2]

降序

a.sort(reverse=True)
      
a
[2, 2, 1, 1]

还有一个sorted()内置函数

生成数字

range(3)生成（0，1，2）三个数，不包括3
range(1，10) 生成 1~9 不包括10
range(1,10,3) 从1开始每个加3 就是[1, 4, 7]

浅拷贝

b=a.cop()

import copy
x=[[1,2,3],[4,5,6]]
y=copy.copy(x)
y
[[1, 2, 3], [4, 5, 6]]

深拷贝

k=copy.deepcopy(x)
k
[[1, 2, 3], [4, 5, 6]]

最大最小值

max(1,2,3)
3
min(1,2,3)
1

健壮性

x=[]
min(x,default="没有")
'没有'

索引位置

x=[1,2,3]
x.index(2)
1

1就是2的位置

元组 tuple

x=1,2
type(x)
<class 'tuple'>
x=(1,2)
type(x)
<class 'tuple'>

x=1,
type(x)
<class 'tuple'>

切片

x=(1,2,3,5,6,7,9,12,23,45,12,56,78)
x[7:11:3]
(12, 12)

从位置7开始到位置10，中间从7走3个，就是取下标为7和10的数

赋值
系列解包

x=(1,2,3)
a,b,c=x
a,b,c
(1, 2, 3)

a,*b=x
a,b
(1, [2, 3])

字典 dict（映像）

键值对key-value

dict={'zhangsan':91,'wangwu':80}

删除

dict.pop('zhangsan')

健壮性

dict.pop('p','no p')
'no p'

删除最后一个

f={'a':1,"b":2,"c":3}
f
{'a': 1, 'b': 2, 'c': 3}
f.popitem()
('c', 3)
f
{'a': 1, 'b': 2}

其他

'a' in f
True
f.keys()
dict_keys(['a', 'b'])
f.values()
dict_values([1, 2])
f.items()
dict_items([('a', 1), ('b', 2)])

f.get('d','没有d')
'没有d'
f.get('a')
1

setdefault()没有就添加进去，有的话就找到

f.setdefault('d','code')
'code'
f
{'a': 1, 'b': 2, 'd': 'code'}

更新
f.update(a=102,c=104)
f
{'a': 102, 'b': 2, 'd': 'code', 'c': 104}
f.update({'a':100,'b':200})
f
{'a': 100, 'b': 200, 'd': 'code', 'c': 104}

迭代器

k
{'a': 1, 'b': 2, 'c': 3}
e=iter(k)
e
<dict_keyiterator object at 0x00000115D76C4950>
next(e)
'a'
next(e)
'b'
next(e)
'c'
next(e)

二维方式进行访问

k={'a': 1, 'b': 2, 'c': 3,'key':{'a': 1, 'b': 2, 'c': 3}}
k['key']['a']
1
p={'tom':[60,70,80],'key':[60,40,70]}
p['tom'][1]
70

key与value互换位置

k={'a':70,'b':80,'c':70,'d':90}
b={v:t for t,v in k.items()}
b
{70: 'c', 80: 'b', 90: 'd'}

集合（set）

添加add()
添加多个

s.update([1,2,3,4,5,6])
s
{1, 2, 3, 4, 5, 6, 9}
s.update([3,4,6],'abcde')
s
{1, 2, 3, 4, 5, 6, 9, 'b', 'c', 'd', 'a', 'e'}

s={1,2,9,4,3,2,4,6}
s
{1, 2, 3, 4, 6, 9}
t=set((2,3,4,5,'67'))
t
{2, 3, 4, 5, '67'}

遍历t

{s for s in t}
{2, 3, 4, 5, '67'}

差集

a={'a','b','c','d'}
b={'c','d','e','f'}
a-b
{'a', 'b'}
b-a
{'e', 'f'}
a^b
{'f', 'a', 'b', 'e'}

删除

s
{1, 2, 3, 4, 5, 6, 9, 'b', 'c', 'd', 'a', 'e'}
s.pop()
1
s
{2, 3, 4, 5, 6, 9, 'b', 'c', 'd', 'a', 'e'}
s.pop()
2
s
{3, 4, 5, 6, 9, 'b', 'c', 'd', 'a', 'e'}

由于是无序的所以是随机进行删除，虽然看上去像是按照顺序

删除“3”
s.remove(3)
s
{4, 5, 6, 9, 'b', 'c', 'd', 'a', 'e'}

清空
s.clear()
s
set()

注意：
type({})
<class 'dict'>
“{}”是空字典，“set()”才是空集合

关联

k=set('pyon')
k
{'n', 'p', 'o', 'y'}
k.isdisjoint({'p'})
False
k.isdisjoint({'p','y','t','h'})
False
k.isdisjoint(set('java'))
True
有关联是False，没关联是True

字符串（str）

是否以p结尾的

s="pythonjavaphp"
s
'pythonjavaphp'
s.endswith('p')
True

看s中是否有k没有返回-1有的话返回第一个所在的下标

s.find('k')
-1
s.find('p')
0

替换字符串，会产生一个新的字符串

s.replace('java','c#')
'pythonc#php'
s
'pythonjavaphp'

字符串分隔，以一个字符串进行分隔，分成头，自己，和尾

s.partition('py')
('', 'py', '\ntho')
s.partition('y')
('p', 'y', '\ntho')

字符串是不可变的字符串分割以y进行分割，分割后y会没有

s.split('y')
['p', '\ntho1']

驼峰
s=' i love java'
s.title()
' I Love Java'

将字符串放在中间，并给他补位到20

s.center(20,'*')
'**** i love java****'
左
s.ljust(21,'*')
' i love java*********'
右
s.rjust(21,'*')
'********* i love java'

剥夺函数

s='** l * love ** python'
s.strip('*')
' l * love ** python'

会删除两边的*

判断是否是回文

x='12321'
if x==x[::-1]:
    print("yes")
else:
    print("no")

yes

两值互换

a,b=3,5
a,b
(3, 5)
a,b=b,a
a,b
(5, 3)

占位符 pass
当运行到pass时不会发生变化

while

while 循环条件:
 循环体
else:
 循环结束后执行

for循环    

for循环语句

for 循环变量 in range(循环初值,循环终值,循环增值)

练习：

*
**
***
****

for i in range(1,6):
    for j in range(1,i):
        print('*',end='')
    print()

   *
  ***
 *****
*******

for i in range(0,5):
    for n in range(0,4-i):
        print(' ',end='')
    for j in range(0,2*i-1):
        print('*',end='')
    print()

for i in range(4):
    print(' ' * (3 - i) + '*' * (i + 1) + '*' * i) 

函数的定义和使用

def 函数名 (函数参数)
    函数体
    return 表达式或值
def fu(x,*y):
    函数体
*代表任意多个参数
def fu(x,**y)
    函数体
**代表字典

def fu(x,/,a,b)
    函数体

def fu(x,/,a,b)
    print(x,a,b)
fu(3,a=3,b=5)
fu(1,2,3)
fu(x=1,2,3)    这个会报错

函数闭包

闭包指的是函数的嵌套。可以在内部定义一个嵌套函数
闭包三要素：
1.函数嵌套
2.内部函数引用了外部函数的变量
3.返回值是内部函数

def funa():
    x=999
    def funb():
        print(x)
    return funb  #返回值是函数的名字
a=funa()()
print(a)
print(a())

装饰器

def decorater(fun):
    def wra():
        fun()
        print("刷漆")
        print("铺地板")
        print("装修结束，是可以住了")
    return wra
@decorater
def house():
    print("毛坯房")

靠近原函数的先进性装饰后执行，里原函数远的后执行

python内置函数

• abs():绝对值
• divmod():取商和余数，参数有两个
• pow(x,y):表示x的y次幂
• round(x,y):对x四舍五入，y是小数位数，可以没有

模块

1.自定义模块：在另外的一个文件当中，可以复用 模块文件.py
2.自然模块

文件

文件目录函数 

os.mkdir("path")    创建目录
os.makedirs("path")        创建多层目录
os.rmdir("path")    删除空目录
shutil.rmtree("path")空目录、有内容的目录都可以删除
os.rename("oldname","newname")    重命名目录
os.path.exists("path")    判断目录是否存在
os.path.isdir        判断目标是否为目录
shutil.copytree("olddir","newdir")    复制目录
shutil.move("olddir","newdir")        移动目录

常用的文件操作函数部分同上

os.mknod("test.txt")        创建空文件
open("test.txt",w)    打开一个文件，如果不存在则创建文件
r：只读，w：只写，a：追加
shutil.copyfile("oldfile","newfile")    复制文件
os.rename("oldfile","newfile")        重命名

读文件

read()
# 1.read()全部读取
#2.read(3)只读三个内容的字节数
#3.seek() 位置定义,表示在这之后全部读取
#是否可以读 readable()
#以行形式读取 readline(),不能放在当read()后面，
#因为流中的内容全被读完，他就读不到了
#以行形式读取 readlines(),把流中的数据变成列表
#str=k.readline()

写文件

write()

异常

try:
    <被检测的语句块>
except:    <异常类型名称>
    <处理异常的语句块>

try:
    <被检测的语句块>
except:    <异常类型名称>
    <处理异常的语句块>
else:
    <无异常时执行的语句块>
finally:
    <不管有没有异常都会输出的语句>

努力学习中~