python自学笔记2

表达式：运算符和操作数所构成的序列

////关于强制转换

>>> int("as")

Traceback (most recent call last):

  File "", line 1, in

    int("as")

ValueError: invalid literal for int() with base 10: 'as'

>>> int("a")

Traceback (most recent call last):

  File "", line 1, in

    int("a")

ValueError: invalid literal for int() with base 10: 'a'

>>> int("12")

12

 

 

 

 

条件分支结构：

if condition:

Exp

else:

Exp

 

 

 

If cond:

Exp

Elif cond:

Exp

Elif cond:

exp

....

 

while:

condition=True

while not condition:

    # print("i am while")

    pass

 

coutn=0;

while coutn<10:

    print("hello,word")

    coutn+=1

else:

    print("eof")

 

For

 

#主要用来循环序列，字典，集合

 

l=[1,2,"32",True]

for e in l:

    if e!=2:

        print(e)

    else:

        print("这个是2")

        break

else:

    print("else")

 

//结果：

PS C:\workspace\python> python for.py

1

这个是2

 

 

/////break后不会执行else语句

 

 

d={1:"hello",2:"world","hello":"java"}

for e in d:

    print(e)

    print(d[e])

///////结果

PS C:\workspace\python> python for.py

1

hello

2

world

hello

Java

 

 

continue  结束本次循环!!

 

 

for i in range(n,m):

print（i）   //打印n---m-1

 

 

for i in range(n,m,s):

print（i）   //打印n---m-1

 

for i in range(0,10,2):
print(i,end="hello") #默认以换行结尾

s=[1,2,3,4,5,6,7,8,9,0]
st=s[0:len(s):2]
print(st)

PS C:\workspace\python> python for.py

0hello2hello4hello6hello8hello[1, 3, 5, 7, 9]

 

无序集没有切片特性：：：

 

 

 

组织结构：

包：模块（.Py文件）：类

 

 

导入包  实际导入的是包下的__init__.py，只要用到某个包下的模块，则__init__.py一定导入

Import 包名.模块名

From 包名 import 模块名

From 包名.模块名 import 元素1，元素2....

 

import m3 #只能导入模块，而不能进一步细化
#有一个 import pack.moudle as selfdefinename

#print(seledefinename.e)

#from packname import moudlename
#print(moudlename.e)

#moudlename 可以 通配 * 

#from packname.module import e/* 同样是统配
#from packname.module import a,b,c,e 同样是统配
#函数，变量的定义可以直接在模块中
#导入一个包，就导入了这个包下的__init__.py模块
print(m3.a)

函数：

#def funcname(para_list):#可以空参
#return 没有return语句，认为return None
def add(x,y):
result=x+y
return result

def printword(code):
print(code)

print(add(1,2))

防止递归定义函数

定义应在使用之前

模块中的定义不会执行，必须在模块中调用才会执行

return可以用来终止函数运行,也可以返回其他函数

可以返回多个值：实际上返回的是一个元组，但是可以用多个变量直接接收

 

def damage(x,y):
d1=x**x
d2=y**y
return d1,d2

a,b=damage(2,4)
print(a,b)
x=damage(2,4)
print(x)



a,b,c=1,2,3
print(a,b,c)
////////////////////////
a,b,c=1,2,3
print(a,b,c)
t=a,b,c  
type(t)  #tuple
x,y,z=t
print(x,y,z)
序列的解包，打包，这个和函数的多个返回值是一样的性质,个数一定要对应，否则会报错
A=B=C=1，也是一种赋值方法

def add(x,y): 形式参数
return x+y
必须参数：参数列表中的参数，调用时必须赋值
关键字参数：在调用时给出形参和实参的对应关系，而不是使用默认的顺序
关系
例如调用add:
add(y=3,x=8)
实际参数：调用时的传入参数
参数过多时，应该将参数封装成一个对象