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

如果x


断言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)