Python基础笔记，后续更新

1,避免‘\n’等特殊字符的两种方式：

1，利用转义字符‘\’

2，利用原始字符‘r’   print r'c:\now'

3,字符串中嵌入双引号等特殊符号

1，利用转义字符‘\’

2，使用单引号括起这个字符串    print ('i l"o"ve fis.com')

2,跨越多行的字符串。使用三个'''........'''

4，条件分支：

if condition:

条件为真执行的操作

else:

条件为假执行的操作

if condition:

action

elif condition:

action

else:

action

python可以有效避免“悬挂else”（if else对应关系出错）

条件表达式（三元操作符）

small = x if x<y else y

如果x<y ,small=x.否则small=y

断言assert：当这个关键字后面的条件为假，程序自动崩溃并抛出异常

assert 3>4

可以利用他置入检查点

5，while条件:

条件为真执行的操作

   for 目标 in 表达式：

循环体

    例：favorite='fishc'

for i in favorite:

print(i,end='')

   range([start,] stop[,step=1])

生成一个从start参数的值到stop参数值的数字序列

   break：终止当前循环体。跳到外层程序

   continue:终止本轮循环，开始下一轮循环（if condition true）

6，and逻辑操作符可以将任意表达式连接在一起，并得到一个布尔类型值

7，引入外援:

1，random模块

2，randint(),返回一个随机的整数

import random 或 from random import randint()

secret=random.randint(1,10)

8，python数据类型

1，数值类型:整型、布尔类型、浮点型、e记法（1.5e10）

2，类型转换：

int()转换为整数

str()转换为字符串

float()转换为浮点数

3，获取关于类型的信息：

type()函数

a=520

type(a)

isinstance()函数

a=12

isinstance(a,int)  --->返回true

isinstance(a,str)  -->返回false

9，Python值常用操作符

+ - * / % **（幂运算） //(地板除法,结果偏小)

   比较操作符   > < >=  <= 

   逻辑操作符   and  or  not

优先级：

幂运算**

正负号 + -

算术操作符   * / // 

+ -

比较操作符   < > =

逻辑擦作福   not and or

10,列表-->可以把整数、浮点数、字符串等打包在一起。数组却不能

创建一个普通列表：

member = ['小甲鱼','小布丁','黑夜']

创建一个混合列表：

mix=[1,'小甲鱼'，3.12，[1,2,3]]

创建空列表：

empty=[]

向列表添加元素：

append():   member.append('福禄娃')-->只能添加一个。末尾

添加

extend():   member.extend(['test','test1'])-->只能以列表

形式添加.末尾添加

insert():   member.insert(1,'牡丹')-->第一位插入牡丹

列表中获取元素： 使用索引index。   mix[1]

列表中删除元素： 使用remove（）。  mix.remove('小甲鱼')

使用del。   del mix[3]/mix

使用pop().   mix.pop()/mix.pop(1)

列表切片： 使用slice。   mix[1:4]/mix[1:]/mix[:4]

列表操作符： >,and,+,*,in/not in

列表的小伙伴： dir(list)

mix.count('小甲鱼')

mix.index('小甲鱼')  

列表逆序： 使用reverse。     mix.reverse()

列表排序： 使用sort。        mix.sort()

mix.sort(func,key)

mix.sort(reverse=True)

11,元组--->不可改变的列表

    和列表的主要不同点：

1，创建和访问一个元组： 大部分用（）/, ；列表用[]

2，元组不可修改数值

3，更新和删除一个元组：temp = temp[:2] + ('test3',) + temp[2:]

del temp

4，IN/NOT IN，关系操作符，逻辑操作符，乘号操作符，连接操作符

12，字符串的各种内置方法

str1='i love fishc.com'

a=str1[:6] + '插入的字符串'+str1[6:]

capitalize()：    str2.capitalize()

casefold()--->全部小写   str2.casefold()

center(width)-->居中，不足空格填充

count(sub[,start[,end]])-->返回sub在string中出现的次数

endswith(sub[,start[,end]])-->以sub结束？

startswith(prefix[,start[,end]])-->以prefix开头

expandtabs([tabsize=8])-->将tab键转换为空格

find(sub[,start[,end]])-->sub是否在字符串中出现

rfind(sub)...

index(sub[,start[,end]])-->跟sub一样，不过会产生异常

rindex(sub..).....

istitle()/isupper()/ljust(width)/lower()/strip()/title()/lower()

join(sub):以字符串做分隔符，分割sub

partion(sub):找到子字符串sub，把字符串分成一个3元组

replace(old,new[,count])

split(sep=none,maxsplit=-1)-->不带参数以空格做分隔符

swapcase()-->字符串大小写翻转

zfill(width)-->返回长度为width的字符串，不够补充空格

13，字符串格式化 replacement

"{0} love {1}.{2:.2f}".format("i","fishc",3.1424)

"{a} love {b}.{c}".format(a="i",b="fishc",c="com")

"{0} love {b}.{c}".format("i",b="fishc",c="com")

格式化符号含义

%c:格式化字符及其ASCII码

'%c %c %c' % (97,98,99)

%s:格式化字符串

%d:格式化整数

%o:格式化无符号八进制数

%x:格式化无符号十六进制数     %X:...(大写)

%f:格式化定点数，可指定小数点后的精度

%e:用科学技术发格式化定点数===%E

%g:根据值的大小决定使用%f或%e===%G

格式化操作符辅助命令

m.n ：m是显示的最小总宽度，n是小数位精度

- ：用于左对齐

+ ：在正数面前添加正号

# ：在八进制面前显示0，在十六进制面前显示0x

0 ：空格用0填充

字符串转义字符

\a:发出系统响铃声

\b、\t、\n

.....

14,序列

列表、元组和字符串的共同点：

都可以通过索引

索引值从零开始

内置方法：

list（）     ――>help-->转换为序列

list()

a=list()

list(iterable)

b='i love fishc.com'

b=list(b)

tuple([iterable])-->把一个可迭代对象转换为元组

b=tuple(b)

str(obj)-->把obj对象转换为字符串

len(obj)-->返回obj的长度

max(序列/元组) /  min(序列/元组)

sum(iterable[,start=0])-->返回序列iterable。。的总和

sorted(序列/元组)-->排序

reversed(序列/元组)-->返回一个迭代器对象

list(reversed(序列/元组))-->返回序列

enumerate(序列/元组)-->返回一个迭代器对象

list(enumerate(序列/元组))-->返回数组形式列表

zip（a,b）-->合并成以元组形式的列表

list(zip(a,b))

15，函数

定义：def Myfunction():

print('this is my first function')

调用：Myfunction()

函数的参数：

def Myfunction(name,age):

print(name+age+'test')

Myfunction('gncao'，‘age’)

函数的返回值:

return  value

形参（parameter）：函数定义时的参数

实参（argument）：实际传递的参数

函数文档：在函数中实现

在函数体中用 '' 或 #

查看函数文档:    1， functionname.__doc__   （四个下划线）

2， help(functionname)

关键字参数：避免参数出乱

def Myfunction(words,name):

...

Myfunction(words='words123',name='name123')

默认参数:

def Myfunction(name='name123',words='words123')

...

收集参数：在参数前面加上*号

def test(*params):

print('参数的长度是:',len(params))

print('第二个参数是:',params[1])

test(1,'小甲鱼',2,4,5,6,7)

def test(*params,exp):

print('参数的长度是:',len(params),exp)

print('第二个参数是:',params[1])

test(1,'小甲鱼',23,4,2,5,7,exp=0)

16,函数有返回值，过程没有返回值

17，函数变量作用域（可见性）

局部：local-->函数内部定义的变量，局部可用

全局：global-->全局可访问

当在函数内部试图修改全局变量时，则会在函数内部新建一个跟

全局变量名相同的局部变量

18，内嵌函数和闭包

global关键字：

def myfun():

global count    ->>>全局变量

count=10

print(count)

内嵌函数:

def fun1():

print('fun1()正在被调用...')

def fun2():

print('fun2()正在被调用')

fun2()

只能通过fun1()访问fun2()

闭包:在一个内部函数中，对外部函数的变量的引用。成内部函数为闭包

def funx(x):

def funy(y):

return x * y

return funy

调用方式:

i=funx(8)

i(5)

或

funx(4)(5)

通过关键字nonlocal可以使得内部函数调用外部函数变量。

def fun1():

x=5

def fun2():

nonlocal x

x*=x

return x

return fun2()

19，递归：recursion（）

def fac(n):

    if n==1:

        return 1

    else:

        return n*fac(n-1)

number=int(input('请输入一个整数:'))

result=fac(number)

print('%d 的阶乘是：%d' % (number,result))

迭代方法：

def fab(n):

    n1=1

    n2=1

    n3=1

    if n <1:

        print('输入有错')

        return -1

    while ( n-2>0 ):

        n3=n2+n1

        n1=n2

        n2=n3

        n-=1

    return n3

result=fab(20)

if result != -1:

    print('总共有%d对小兔子诞生：' % result)

递归方法：

def fab(n):

    if n < 1:

        print('error')

        return -1

    if n==1 or n==2:

        return 1

    else:

        return fab(n-1) + fab(n-2)

result=fab(20)

print('总共有%d对兔子诞生' % result)

但是递归的效率比较低

20,字典（key-value）

映射/序列

例1：

dict1={'李宁':'一切皆有可能','耐克':'just do it','阿迪达斯':'impossible 

is nothing'}

print('李宁的口号是:',dict1['李宁'])

例2:

dict3=dict((('f',70),('i',105)))

例3:

dict4=dict(小甲鱼='编程改变世界',test='test')

dict4['小甲鱼']='修改小甲鱼对应的value'     -->如果没有该KEY，则会自动添

加一个KEY

字典的内建方法:

0,dict2['key']-->访问字典的元素

1,fromkeys(s[,v])    -->创建或查询key

dict1.fromkeys((1,2,3))

{1: None, 2: None, 3: None}

 dict1.fromkeys((1,2,3),'number')

{1: 'number', 2: 'number', 3: 'number'}

2,

keys()-->dict.keys() -->打印出dict的所有key

values()-->dict.values() -->打印出dict的所有value

items()-->dict.items() -->打印出dict所有(key,value)

get()--> dict.get(key) -->打印key对应的value

dict.get(key,'text')-->打印key对应的value，如果不存在，则打印

text

in操作符 --> key in dict2

clear() -->dict.clear() -->清空dict的数据

copy() -->b=a.copy()    -->拷贝字典

id(a)-->查看id

pop(key) --> dict.pop(key) -->弹出key

popitem() -->dict.popitem()  -->随机弹出key

setdefault() -->dict.setdefault(key)  -->新建key

update()   -->dict.update(dict)   -->更新字典

21，集合   --->唯一性

num={1,2,3,4,5}

set()-->set1=set(列表/元组/字符串)

不支持索引

访问集合中的值:

使用for循环一一查找

使用IN 或者 NOT IN

add()-->set1.add(value)

remove()-->set1.remove(value)

不可变集合:

num3=frozenset(元组/列表)

22,文件

输入-->处理-->输出

内存--->磁盘

open()打开文件:

open('filename/path',mode='rwxabt+U')

文件对象方法:

f.close() -->关闭文件

f.read(size=-1)  -->从文件读取size个字符

f.readline() -->以写入模式打开，如果文件存在，则在末尾添加

f.write(str) -->将str写入文件

f.writelines(seq)  ->向文件写入seq序列。seq应该是一个返回字符串序列

f.tell() -->返回当前的位置。书签

f.seek(offset,from)  -->在文件中移动文件指针，从from偏移offset字节

for each in f:    ---->浏览整个文件

print(each)