适用的python小白

本人编程小白 不喜勿喷?

python基础:

算术运算符：+ - * /

比较（关系）运算符：==  !=  >  <  >=  <=

逻辑运算符: =  +=  -=  *=   /=  %=  **=(幂赋值运算符)  //=(取整)

位运算符: &  |  ^  ~  <<  >>

成员运算符: in(如果在指定的序列中找到值返回 True，否则返回 False。)   

not in(如果在指定的序列中没有找到值返回 True，否则返回 False。)

#!/usr/bin/python3

 a = 10 

b = 20 

list = [1, 2, 3, 4, 5 ];

 if ( a in list ): print ("1 - 变量 a 在给定的列表中 list 中") 

else: print ("1 - 变量 a 不在给定的列表中 list 中") 

if ( b not in list ): print ("2 - 变量 b 不在给定的列表中 list 中")

 else: print ("2 - 变量 b 在给定的列表中 list 中")

 # 修改变量 a 的值 

a = 2 

if ( a in list ): print ("3 - 变量 a 在给定的列表中 list 中") 

else: print ("3 - 变量 a 不在给定的列表中 list 中")

 以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中2 - 变量 b 不在给定的列表中 list 中3 - 变量 a 在给定的列表中 list 中

 

身份运算符: is 是判断两个标识符是不是引用自一个对象

        is not 是判断两个标识符是不是引用自不同对象

#!/usr/bin/python3 

a = 20

 b = 20

 if ( a is b ):

 print ("1 - a 和 b 有相同的标识") 

else: print ("1 - a 和 b 没有相同的标识") 

if ( id(a) == id(b) ): print ("2 - a 和 b 有相同的标识") 

else: print ("2 - a 和 b 没有相同的标识") 

# 修改变量 b 的值 

b = 30

 if ( a is b ): print ("3 - a 和 b 有相同的标识") 

else: print ("3 - a 和 b 没有相同的标识") 

if ( a is not b ): print ("4 - a 和 b 没有相同的标识") 

else: print ("4 - a 和 b 有相同的标识")

以上实例输出结果：

1 - a 和 b 有相同的标识2 - a 和 b 有相同的标识3 - a 和 b 没有相同的标识4 - a 和 b 没有相同的标识

 

数字:  

var1 = 1 var2 = 10

del var  用del 删除对象

del var_a, var_b

int(x) 将x转换为一个整数。

float(x) 将x转换到一个浮点数。

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y     x 和 y 是数字表达式。

 

字符串：

#!/usr/bin/python3 

var1 = 'Hello World!'

 var2 = "Runoob"

 print ("var1[0]: ", var1[0]) 

print ("var2[1:5]: ", var2[1:5])

以上实例执行结果：

var1[0]:  H

var2[1:5]:  unoo

#!/usr/bin/python3 

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

 

 

列表：相当于C语言数组

#!/usr/bin/python3 

list1 = ['Google', 'Runoob', 1997, 2000];

list2 = [1, 2, 3, 4, 5, 6, 7 ];

print ("list1[0]: ", list1[0]) 

print ("list2[1:5]: ", list2[1:5])

以上实例输出结果：

list1[0]:  Google

list2[1:5]:  [2, 3, 4, 5]

删除列表元素  del list[2]

嵌套就是2维数组 x[[‘a’,’b’,’c’],[1,2,3]]

 

元组：元组不能修改 列表可以修改  

只有一个元素时 要加 , 不然默认为int 型

>>>tup1 = (50)

 >>> type(tup1) # 不加逗号，类型为整型

 <class 'int'>

>>> tup1 = (50,) 

>>> type(tup1) # 加上逗号，类型为元组 

<class 'tuple'>

修改元素：可以用拼接字符串

A=(12,34.56)

B=(‘abc’,’xyz’)

Ab=A+B

删除 del B

复制列表l1=l[:]

 

字典：类似于结构体   整个字典用{}中

D={key:value1,key2:value2}

键必须是唯一的，但值则不必的

值是可以取任何数据类型 但键是不可变的

 

dict1 = { 'abc': 456 }; 

dict2 = { 'abc': 123, 98.6: 37 };

 

#!/usr/bin/python3 

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name'] # 删除键 'Name' 

dict.clear() # 清空字典 

del dict # 删除字典 

print ("dict['Age']: ", dict['Age']) print ("dict['School']: ", dict['School'])

执行后字典将不存在

 

访问字典里的值

#!/usr/bin/python3 

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print ("dict['Name']: ", dict['Name']) 

print ("dict['Age']: ", dict['Age'])

以上实例输出结果：

dict['Name']:  Runoob

dict['Age']:  7

 

删除字典元素:

 #!/usr/bin/python3 

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name'] # 删除键 'Name' 

dict.clear() # 清空字典

 del dict # 删除字典

 print ("dict['Age']: ", dict['Age']) 

print ("dict[Class]: ", dict['Class'])        #删除后字典将不存在

键不能变 值可以  可以用数字，字符或元组充当 列表不行

#!/usr/bin/python3 

dict = {['Name']: 'Runoob', 'Age': 7}

 print ("dict['Name']: ", dict['Name'])

 

遍历字典 for item in book:print key,book[key]     book是字典名

         Bo=book.items()

         dict(Bo)

Book.get(‘simon’)    simon是键值

‘Simon’ in book 存在返回 true

Book1=book   把字典book给了Book1 但并不实际分配内存 类似C语言的指针

book1=book.copy() book1现在是有实际的内存空间的

 

文件：

文件类型 file

 f=open(‘demo.txt’,’w’)打开创建一个文件 写的方式 第2次打开时会清空

f.write(‘hello\n’)往文件里面写，但里面并没有内容，实际上在内存里面

f.flush() 调用这个函数后 把内存里面的东西写入到硬盘上

f.close() 关闭文件 在程序关闭后也会默认的关闭

f=open(‘demo.txt’,’r’)  ‘a’是追加方式

Content=f.read()  print content  一次性读完文件

读完后 一样有文件指针的概念

可以用f.seek(0)回到开头

S=f.read(5)读5个字节

 

f=open(‘demo.txt’)

For line in f.readlines():  按一行一行显示文本 会自动添加换行符

 

 

If嵌套

if 表达式1：

语句

if 表达式2:

   语句

elif  表达式3

    语句

else:

    语句

elif 表达式4：

     语句

else:

     语句  

 

循环：python没有do while只有while

  while 判断条件：

        语句

例：

N=100

Sum=0

A=1

While a<=N:

      Sum+=a

      A++

Print(“1到%d之和为%d”%(N,Sum))

 

例2：

while 1:

    num=int(input("输入一个数字:"))

    print("你输入的数字是:",num)

print("good bye")

Ctrl+c可以退出循环

 

while 表达式:

      语句

else:

   语句

 

for语句

 La=[“c”,”c++”,”perl”,”python”]

 for x in La:

     Print(x)  

内置函数 range()

for i in range(5):print(i)  打印0到4

for i in range(5,9):print(i)  打印5到8

for i in range(0,10,3):print(i) 每隔3个打印 范围是0到10        0  3  6  9

for i in range(-10,-100,-30):print(i)    -10  -40    -70

a=['A','B','C','D','E'] 有序的列表

for i in range(len(a)):print(i,a[i]) 

打印出  0 A

1 B

2 C

3 D

4 E

Python 同样有break和 continue作用和C语言一样

循环语句可以有else 子句 在条件为假时 执行 但循环语句被break终止时不执行

for n in range(2, 10):

for x in range(2, n):

 if n % x == 0: print(n, '等于', x, '*', n//x) 

break 

else:

 # 循环中没有找到元素 

print(n, ' 是质数')

 

pass 语句 是空语句是为了保持程序结构的完整性 一般用作占位符

While True: pass  #等待键盘中断 (ctrl+c)

但pass相当于延时的作用 在程序中并不能把语句终止执行

 

函数用关键字 def定义 函数的传参与C语言一样

python中 类型属于对象，变量是没有类型的 a=[1,] a=”123”

def 函数名（参数）:

函数体

 

传值不会改变原值的大小，传地址会改变原值

传参可以不需要使用指定顺序，但是要指定

def pr(a,b):

print(“a”,a)

print(“b”,b)

pr(b=10,a=90)

 

默认参数 调用函数时，如果没有传递参数，就会使用默认参数

def pr(a=1,b=2):

print(a)

print(b)

return

pr()/pr(10,90)

 

加了*的参数会以元组的形式导入

def pr(*a):

print(a)

return

pr(30,90,20)

输出：(30,90,20)

带**的参数会以字典、键值对的形式导入

def pr(**a):

print(a)

pr(a=2,b=3)

输出 {‘a’:2,’b’:3}  

 

匿名函数   关键字 lambda

A=lambda e,u:e+u    冒号后不能换行

 

作用域  在内部作用域中想要修改外部作用域变量是用global

 A=1

 def fun():

     global A

     A=100

     print(A)

fun()

print(A)

修改嵌套作用域 关键字nonlocal

def op():

A=10

def inner():

    nonlocal A

    A=1000

    print(“1”,A)

inner()

print(“2”,A)

op()

输出：1 1000

      2 1000    

 

数据结构：

  列表可以修改  字符串和元组不能

 

list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x 在列表中出现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于a[:]。

 

列表可以当做堆栈使用 后进先出 list.append()把一个元素添加达到栈顶 用不指定索引的list.pop()把一个元素从堆栈定释放出来

 

将列表当队列   先进先出

 from collections import deque     建一个队列

 A=deque([“er”,”ws”,”ko”])

1. append(“op”)添加到列尾

1. popleft()    把首个元素删除   

 

每个列表推导式都在for后面跟一个表达式 如果表达式推出一个元组，就必须使用括号a1=[2,3,4]

[[3*x for x in a1]]

打印：[6,9,12]           推导式没有改变A1实际的值

 

[3*x for x in a1 if x>3]  a1中的元素大于3的才计算

[a1[i]*a2[i] for i in range(len(a1))]

将3*4的矩阵换成4*3的矩阵

[[row[i] for row in a] for i in range(4)]

 把3*4的每行第一个元素矩阵 变成4*3矩阵的每个元素

 

 元组由逗号分隔的值组成  元组输入时可以不加括号 但输出时总有括号 便于表达式的嵌套结构

 

集合用(无序不重复的集合){}表示 如果要创建一个空集合 必须用set()表示

a=set(‘12334’)

集合同样有 - | & ^  的操作

集合也支持推导式

A={x for in ‘abcd’ if x not in ‘abc’}  把集合中 abc 清除

 

字典 以键为索引 可以看作无序的键=》值对集合，在同一个字典里面关键字必须是互不相同的

一对大括号创建一个空的字典{}

 

遍历技巧：

 在字典中遍历时 可以用items()方法同时读出:

 For k,v in a1.items():

     Print(k,v)  k,v是键值对

同时遍历2个或更的序列 可以用zip()组合  zip()可以只带一个参数

For q,v in zip(a1,a2):

Print(‘what is your{0} it is {1}’.format(q,v))

按顺序遍历一个序列 sorted()

For f in sorted(set(a1)):

Print(f)

 

import 用来引入文件 模块

也可以通过from....import语句导入指定的部分

from s1 import a1,a2

 

 

格式化输出：

str() 返回一个字符串类型   str(s)  str(1/7)

repr()  产生一个易于解释器易读的表达形式 但与str()不同的是repr返回的是双引号

repr() 函数的参数可以是任何对象 列表 字典等

end=’’ 相当于是转行\n     rjust(2)格式化对齐   调用方式：str(s).rjust(2) 参数表示右对齐2个字符宽度

print(‘{0:2d}{1:3d}{2:4d}’.format(x,x*x,x*x*x))

format 参数格式化，也可以指定名字

my name is {name}, {name} age is {age}'.format(name='wang',age=10)

 括号里面是数字表示传入对象的位置

 print(‘{0}和{1}’.format(‘op’,’io’))

=》op和io

 print(‘{1}和{0}’.format(‘op’,’io’))

=>io和op

可以传入一个字典 用[]来访问键值 []里面是关键字

Ta={‘goole’:1,’Runoob’:2,’taobao’:3}

print(‘goole:{0[Runoob]:d};Runoob:{0[goole]:d};taobao:{0[taobao]:d}’.format(Ta))

=》goole: 2;Runoob: 1;taobao: 3

旧的字符串格式化：

 import math

 print(‘%3.3f’%math,pi)

=》3.142

但旧的字符串格式最终会被淘汰

从键盘输入

Str=inpur(“请输入：”)

print(Str)

 

Python 的错误和抛出异常

   逻辑：先执行关键字try 里面的内容 遇到错误就去找关键字 except里面的异常抛出 执行异常抛出的代码 如果没有异常与except匹配 就把异常传递上层的try中

如果有else语句 那么必须放在所有except的后面 将在try 没有异常时执行else

try:语句1

except IOError:

      print(‘cannot open’,arg)

else:语句2

可以用关键字raise语句抛出指定的异常 raise NameError(‘jia’)

 

可以再次抛出异常 但不去处理 仅仅想知道是否抛出异常 用一个raise语句

try:

   Raise NameError(‘io’)

except NameError:

print(‘an exception flew by’)

#再次抛出

raise

可以自定义类来建立自己的异常  抛出的就是自定义类的异常 然后根据抛出的异常去执行其他代码

#自定义类先加载 但不执行

class myerror(Exception):

    def __init__(self,value):

        self.value=value

    def __str__(self):

        return repr(self.value)

 

try:

    raise myerror(2*2)    #先执行这里 但会因为异常终止 去执行except

except myerror as e:  #抛出异常的执行

    print('my exception occurred,value:',e.value)

    

定义清理行为 用关键字finally  不管有没有发生异常 finally都会执行 更多是如果发生了异常 但except没有把它截住 那么这个异常就会在finally中执行 像C语言switch

的define

 

def div(x,y):

try:

 #先执行这里 如果调用div没有异常 就执行else和finally

 #有异常抛出就执行 except//如y==0或x,y的值为字符//和finally

        a=x/y

    except ZeroDivisionError:

        print("division by zero")

    else:

        print("result is",a)

    finally:

        print("executing finally clause")

 

预定义的清理行为：

关键字 with语句可以保证对象[python里面所有都是对象]在使用完后一定会正确的执行清理 不管会不会抛出异常或是程序停止

with open(“myfile.txt”) as f；

     for a in f:

         print(a,end=’’)

这段代码作用是尝试打印出myfile.txt文件中的内容就算程序处理中有问题文件总会关闭

一个模块被另一个模块第一次引入时，他的程序将运行 如果想让这个模块中的某一个程序不执行 可以用__name__属性来使该程序仅仅在自己的模块上运行

if __name__==’__main__’:  print(‘程序自身在运行’)

else: print(‘来自另一个模块’)

 

 

 

python基础总结：

   python内核架构是C语言写的  在语法和基础定义上与C差不多  不同的是 加入了面向对象的思想  在python中一切都是对象。 在引用对象的时候，实际上是计算机寻址的过程，这也是python在定义变量时不用定义类型的原因，也是列表可以存放不同类型的原因.

模块化的编程思路使python的移植性很高，下载模块也很方便。不同的模块有自己不同的作用。有面向网络的，面向游戏的，需要注意的是要注意python模块的版本，感觉python2和python3完全是不同的语言风格和语法。抛出异常是python区别与C语言最大的地方，他的基本思路也来自与模块化的思想。

人生苦短 我要学python

 

参考文档：http://www.runoob.com/python3/python3-tutorial.html

第一次写这东西

欢迎补充和讨论

 QQ:1831132568

 邮箱:1831132568@qq.com