玩转python

1.基础语法

#1.每个缩进层次使用单个制表符,保持一致，缩进相同的一组语句构成一个代码块，我们称之代码组
#2.python中单行注释采用 # 开头，多行注释使用三个单引号(’’’)。
#3.建议函数之间使用空行方便维护或重构
#4.同一行显示多条语句，使用；连接
#5.print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号 ,

print(“hello world!”)

1.1变量类型

#1.Python 中的变量赋值不需要类型声明,下面是python3的打印语法，要加括号，python2不加，记得区分。

zhengxing = 100
fudianxing = 100.0
string = “bom”
print (zhengxing)
print (fudianxing)
print (string)

1.2标准数据类型

1. Numbers（数字）

a = 1
#注意：long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转
#为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。
c = 0.01
d = 1+3.14j #复数
print(d)

2. String（字符串）

s = ‘abcdef’
print(s[1:5])
print(s[3:])
print(s+“ghijk”)

3. List（列表*）

list1 = [100,100.0,‘bom’]
list2 = [2.3,‘john’,12,“hello world!”]
print(list1)
print(list1[0])
print(list1[1:2]) #截取
print(list1[1:])
print(list1 * 2) #输出两次
print(list1 + list2)
list1[0] = 999 #更新
print(list1)
list3 = [100,25,32]
print(“列表中的最大值:”,max(list3))

4. Tuple（元组） 元组相当于只读列表，是不允许更新的。而列表是允许更新的

zu1 = (100,100.0,‘bom’)
zu2 = (2.3,‘john’,12,“hello world!”)
print(zu1)
print(zu1[0])
print(zu1[1:2])
print(zu1[1:])
print(zu1 * 2)
print(zu1 + zu2)

5. Dictionary（字典） 键必须是唯一的，但值则不必

dict1 = {‘name’:‘alice’,‘age’:15,‘class’:‘cs01’}
print(“name:”,dict1[‘name’]) #查询
print(“age:”,dict1[‘age’])
dict1[‘age’] = 19 #更改
dict1[‘school’] = “武汉大学” #添加
print(“age:”,dict1[‘age’])
print(dict1)
del dict1[‘school’] #删除键school
print(dict1)
print(len(dict1)) #字典的长度
print(type(dict1)) #返回变量类型
dict1.clear() #清空字典
print(dict1)

6. 集合（set）

空集合创建,避免与空字典语法冲突 set()
jihe1 = {‘zscheng’,‘huawei’,‘oppo’,‘oppo’} #非空集合创建
print(jihe1)
print(‘oppo’ in jihe1 ) #判断元素是否在集合里
jihe2 = {‘junjun’,‘leilei’,‘oppo’}
print(jihe1 - jihe2)
print(jihe1 | jihe2)
print(jihe1 & jihe2)
print(jihe1 ^ jihe2) # 不同时包含于jihe1和jihe2的元素

jihe2.add(‘nihaoa’) #添加元素
print(jihe2)
jihe2.update([1,4],{‘name’:‘gyf’}) #添加多个元素
print(jihe2)
jihe2.remove(‘name’) #移除元素
print(jihe2)
print(len(jihe2)) #计算元素个数
print(‘leilei’ in jihe2) #判断元素是否在集合里
jihe2.clear() #清空集合
print(jihe2)

2. 逻辑结构 没有switch-case和do-while

入门案例

a, b =0,1
while b<100:
print(b, end=’,’)
a, b = b, a+b

2.1.条件结构 if – elif – else

1. demo1

print()
var1 = 100
if var1: #冒号:表示接下来是满足条件后要执行的语句块
print(“1-if条件为true”)
print(var1)

2. demo2

var2 = 0;
if var2:
print(“2-if条件为false”)
print(var2)
print(“Good bye!”)

3. demo3

age = int(input(“请输入你的年龄:”))
print()
if age <=0:
print(“你还在娘胎吧”)
elif age < 18:
print(“你未成年”)
elif age >=18:
print(“你成年了”)
input(“点击enter退出”)

4. demo4

number = 12;
guess = -1;
print(“数字猜谜游戏”)
while guess != number:
guess = int(input(“请输入猜的数字:”))
if guess == number:
print(“恭喜你，猜对了”)
elif guess < number:
print(“猜小了”)
elif guess > number:
print(“猜大了”)

5. demo5 if嵌套

num = int(input(“请输入一个数字:”))
if num%20:
if num%30:
print(“你输入的数字可以整除2和3”)
else:
print(“你输入的数字可以整除2，但不能整除3”)
else:
if num%3==0:
print(“你输入的数字能整除3，但不能整除2”)
else:
print(“你输入的数字既不能整除2，也不能整除3”)

2.2.循环语句 for 和 while

1. demo1 while

n = 100;
sum = 0;
p = 1;
while p <= n:
sum = sum + p
p += 1
print(“1到%d之和为:%d”%(n,sum))

2. demo2 无限循环 用于服务器上客户端的实时请求

var3 = 1
while var3 == 1:
j = int(input(“请输入一个数：”))
print(“你输入的数是：”,j)
print(“bye”)

3. demo3 while-else

count = 0
while count < 5:
print(count,“小于5”)
count += 1
else:
print(count,“大于或等于5”)

4. demo4

flag = 1
while (flag):print(“python高级语言”) #只有一条可以并排着写
print(“bye”)

5. demo5 for

yuyan = [“C”,“Java”,“H5”,“Js”,“python”]
for x in yuyan:
print(x)

6. demo6
   for r in ‘hubei’: #遍历字符串
   print®

7. demo7

for y in yuyan:
if y == ‘python’:
print(“爬虫语言”)
break #跳出当前循环
print(“循环结果:”,y)
else:
print(“没有这个语言”)
print(“完成循环”)

8. demo8 遍历数字序列-range

for k in range(5):
print(k)

for k in range(9,19):
print(k)

for k in range(9,19,3):
print(k)

10. demo10 range+len

liebiao = [‘baidu’,‘tengxun’,‘aliyun’]
for i in range(len(liebiao)):
print(i,liebiao[i])

11. demo11 break和continue

n = 5
while n > 0:
n -= 1
if n == 2:
break
print(n)
print(‘循环结束’)

n = 5
while n > 0:
n -= 1
if n == 2:
continue
print(n)
print(‘循环结束’)
‘’’

12. demo12

while True:
pass # 等待键盘中断 (Ctrl+C)

3. IO读写

3.1写

file = open("F:/workspace/pythonstu/demo.txt","w")

file.write("Python 是一个非常好用的语言。\n是的，的确好用！\n")

file.close()

3.2读

file = open("F:/workspace/pythonstu/demo.txt","r")    
str = file.read()#readline()读取单独的一行 readlines()读取所有行
print(str)
file.close()   

3.3权限表

4. 遍历技巧

4.1 字典遍历 用items()

zidian = {"name":"zscheng","age":12}
for i,j in zidian.items():
    print(i,j)    

4.2 列表遍历 用enumerate()

list = ['a','b','c']
for k,l in enumerate(list):
    print(k,l)   

4.3 反向遍历 用enumerate()

list2 = ['a','b','c']
for k in reversed(list2):
    print(k)  

4.4 排序 用sorted()

list3 = ['f','b','c']
list3.append('d') #添加到列表的结尾
del list3[0] #按索引删除值
for k in sorted(list3):
    print(k)  

5.异常

#错误和异常  语法错误(编译时异常)和异常(运行时异常)
   
    #demo1 语法错误
#3 + i*2    
    #demo2 除数为零ZeroDivisionError
i = 10/0
print(i)   

    #demo3  异常处理 try/except/else/finally
try:
    i = 10/0
except ZeroDivisionError:    
    print("除数不能为零")
else:
    print("没有异常，执行我")
finally:
    print("无论如何，我必须得执行")    
   
    #demo4 抛出异常 raise (相当于Java里的throws)
x = 10
if x > 5:
    raise Exception('x不能大于5。x的值为{}'.format(x)) #{}是占位符    
    #直接写raise就是不处理异常
 
    #demo5 预定义的清理行为 用了with就算在处理过程中出问题了，文件 f 总是会关闭 
with open("F:/workspace/pythonstu/demo.txt") as f:
    for line in f:
        print(line,end="")

6. 函数

 #demo1 不带参数
def hello():
    print("Hello word!")

hello()
    
    #demo2 带参数  计算面积
def area(width,height):
    return width * height;
w = 4
h = 5
print("width=",w,"height=",h,"area=",area(w,h))
 
    #demo3   传不可变对象实例 
def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)
print( b ) # 结果是 2   

    #demo4   传可变对象实例
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
    #demo5  调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)    
    #demo6
def printme(str):
    print(str)
    return   #可以不写，无返回值

printme("可以的")

    #demo7 传参不用按顺序的写法  默认参数
def printInfo(name,age = 10):
    print("name:",name)
    print("age:",age) 
printInfo(age=100,name="大王")  
print("--------------------")  
printInfo(name="小王")    

    #demo8  不定长参数 一个*，以元组形式导出
def f8(a,*b):
    print(a)
    print(b)
f8(12,13,14)        
f8(12)

    #demo9  不定长参数 两个*，以字典形式导出    
def f9(a,**b):
    print(a)
    print(b)
f9(12,m=1,n=3)

    #demo10 *单独出现,* 后的参数必须用关键字传入
def f10(a,b,*,c):
    return a+b+c
f10(1,2,c=3)

    #demo11 匿名函数 lambda
sum = lambda a, b: a + b
print("相加后的值:",sum(10,20))   

    #demo12 return语句 不带参数值的return语句返回None
def f12(a, b):
    total = a + b
    return total
total = f12(1,5)
print(total)    

7. 面向对象

 #demo1 类对象和类方法
class MyClass:
    i = 123456
    __j = 2#__表示私有，不能在类的外部被使用
    def __init__(self,a,b):
        print(self)#当前对象的地址
        print(self.__class__)#指向类
        self.c = a
        self.d = b   
    def f(self): #每个类的方法都必须有参数self，相当于this,代表类的实例
        return "hello world"

x = MyClass(3,5)
print("MyClass的属性:",x.i)
print("MyClass的方法:",x.f())    
print(x.c,x.d) 
'''   
    #demo2 继承,python可以多继承
class people:
    name = ''
    age = 0
    __weight = 0
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("父类%s说，我%d岁,%d斤"%(self.name,self.age,self.__weight))
class student:
    grade = ''
    def __init__(self,g):
        self.grade = g
        print(self.grade)

class haha(people,student):#多继承
    def __init__(self,n,a,w,g):
        people.__init__(self,n,a,w)
        student.__init__(self,g)
z = haha("haha",12,120,"大三")
print(z.speak())   
    #demo3 方法重写
class heihei(people):
    def __init__(self):
        print("heihei")
    def __siyou(self):
        print("私有方法只能在类的内部使用")
    def speak(self):
        print("调用子类的speak方法") 
        self.__siyou()
h = heihei()
h.speak()
super(heihei,h).speak()
   
    #类的专有方法
#__init__ : 构造函数，在生成对象时调用
#__del__ : 析构函数，释放对象时使用
#__repr__ : 打印，转换
#__setitem__ : 按照索引赋值
#__getitem__: 按照索引获取值
#__len__: 获得长度
#__cmp__: 比较运算
#__call__: 函数调用
#__add__: 加运算
#__sub__: 减运算
#__mul__: 乘运算
#__truediv__: 除运算
#__mod__: 求余运算
#__pow__: 乘方   

8.as的三种用法

8.1 第一种是和with结合使用，主要用于文件的读写操作，省去了关闭文件的麻烦

with open("文件路径","读写方式") as 赋值变量:
    执行代码块

8.2 导入模块起别名

import paddle.fluid as fluid

8.3 第三种是和except组合使用，将捕获到的异常对象赋值给e

except Exception as e:
    print ("e=",e)

总结

python语言和Java有很多类似，给我最深的体会是，python语言严格缩进，少了类型的定义，而且不用写更多的符号，例如分号，括号等，另外python的异常格式try/except/else/finally,函数的修饰符def,面向对象即定义类，需要注意类方法和普通方法有一点不一样，类方法都会有self参数-类实例（类似于this),私有属性和方法用__开头，只能类内部调用；python支持多继承，这与Java不一样，python是一门简洁高效的面向对象语言，是入手深度学习的基础语言。