第一章 TensorFlow基础——python语法（三）

简明Python基础（三）

此为jupyter notebook导出文档，如果习惯jupyter界面可以下载文件
链接：https://pan.xunlei.com/s/VMn5shjbvhvIPMqdURC6TZHXA1
提取码：pafn
复制这段内容后打开手机迅雷App，查看更方便

Python的行

python中没有强制的语句中止符

多行语句

Python语句中一般以新行（换行）作为语句的结束符

thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 = 1
thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable2 = 2
thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable3 = 3

# 这一条语句写在一行太长了，不方便看也不美观
plusResult = thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 + thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable2 +thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable3
print(plusResult)

# 直接分行不可行，会报错
plusResult = thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 + 
thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable2 +
thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable3

print(plusResult)

  File "", line 2
    plusResult = thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 +
                                                                            ^
SyntaxError: invalid syntax

# 可以使用斜杠()将一行的语句分为多行显示
plusResult = thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 +
thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable2 +
thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable3

print(plusResult)

语句中包含[],{}或者()这些括号中间换行的就不需要使用多行连接符

days = ('Mon','Tue','Wed',
       'Thu','Fri','Sat','Sun')
print(days)

('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun')

控制语句条件语句 if

代码块是通过缩进来指示的
缩进表示一个代码块的开始，逆缩进则表示一个代码块的结束
声明以冒号:字符结束,并且开启一个缩进级别

在if 和 else elif 的条件后面别忘记冒号

print("请输入体重（kg）：")
weight = float(input())
if weight > 90 :
    print("该减肥啦！！！")

if else 语句

C++ java 的else if语句在Python改为了 elif

print("请输入体重（kg）：")
weight = float(input())
if weight > 90 :
    print("该减肥啦！！！")
else :
    print("身材保持的不错！！！")

# java 和 C++中不允许的多重不等式 python中允许 可以写成 1 90 :
    print("该减肥啦！！！")
elif 60 
while循环语句 
循环语句允许执行一条语句或语句块执行多次 
# 统计6在2的100次方中的次数：
num = 2 ** 100
print(num)

count = 0

while num > 0 :
    if num % 10 == 6:
        count = count + 1
    num = num //10

print(count)
 
1267650600228229401496703205376
5
 
for 循环语句 
for 循环变量 in 序列 : 
# 统计6在2的100次方中的次数：
num = 2 ** 100
print(num)
count = 0
for digit in str(num):
    if digit == "6" :
        count = count + 1
print(count)
 
1267650600228229401496703205376
5
 
使用for和range来枚举列表中的元素 
# 输出0~4 不包括 5
for i in range(5):
    print(i)
 
0
1
2
3
4
 
# 左闭右开
for x in range(1,5):
    print(x)
 
1
2
3
4
 
列表推导式 
列表推导式(List Comprehension)提供了一个创建和操作列表的有力工具 
列表推导式由一个表达式以及紧跟着这个表达式的for语句构成，for语句还可以跟0个或多个if或for语句 
#本质是多重循环
list1 = [1,2,3]
list2 = [4,5,6]
[x * y for x in list1 for y in list2]
 
[4, 5, 6, 8, 10, 12, 12, 15, 18]
 
数值判断可以链接使用，例如1 
[x for x in list1 if 4>x>1]
 
[2, 3]
 
多重循环 
# 9 9乘法表
for i in range(1,10):
    for j in range(1,i+1):
        result = j * i
        print('%s x %s = %-5s ' % (j,i,result) , end=' ')#end=' '不换行
    print()
 
1 x 1 = 1      
1 x 2 = 2      2 x 2 = 4      
1 x 3 = 3      2 x 3 = 6      3 x 3 = 9      
1 x 4 = 4      2 x 4 = 8      3 x 4 = 12     4 x 4 = 16     
1 x 5 = 5      2 x 5 = 10     3 x 5 = 15     4 x 5 = 20     5 x 5 = 25     
1 x 6 = 6      2 x 6 = 12     3 x 6 = 18     4 x 6 = 24     5 x 6 = 30     6 x 6 = 36     
1 x 7 = 7      2 x 7 = 14     3 x 7 = 21     4 x 7 = 28     5 x 7 = 35     6 x 7 = 42     7 x 7 = 49     
1 x 8 = 8      2 x 8 = 16     3 x 8 = 24     4 x 8 = 32     5 x 8 = 40     6 x 8 = 48     7 x 8 = 56     8 x 8 = 64     
1 x 9 = 9      2 x 9 = 18     3 x 9 = 27     4 x 9 = 36     5 x 9 = 45     6 x 9 = 54     7 x 9 = 63     8 x 9 = 72     9 x 9 = 81     
 
break语句 
break语句用在while和for循环中 
break语句用来终止循环语句，即循环条件没有False或者序列还没被完全递归完，也会停止执行循环语句 
# 统计第1个9在2的100次方中出现的位置：
num = 2**100
pos = 0
for digit in str(num) :
    pos = pos + 1
    if digit == "6":
        break
print("2**100 is: %d nthe first position of 6 is Pos.%d"  % (num, pos))
 
2**100 is: 1267650600228229401496703205376 
the first position of 6 is Pos.3
 
如果在嵌套循环中，break语句将停止执行本层的循环 
# 求2到10之间的素数
i = 2
while(i<=10):
    flag = 0
    j = 2
    while(j <= (i/j)):
        if i%j == 0 :
            flag = 1
            break
        j = j + 1
    if flag == 0 :
        print(i,"是素数")
    i = i + 1
 
2 是素数
3 是素数
5 是素数
7 是素数
 
continue语句 
continue语句用来跳过当前循环的剩余语句，然后继续进行下一轮循环 
# 求在2的100次方中删除所有的6后的数字
num = 2**100
without6 = ''
for digit in str(num):
    if digit == '6':
        continue
    without6 += digit
print("2**100 is: %d nwithout 6 is: %s"  % (num, without6))
 
2**100 is: 1267650600228229401496703205376 
without 6 is: 12750002282294014970320537
 
pass语句 
pass语句是空语句，是为了保持程序结构的完整性，一般用做占位语句 
# 求在2的100次方中删除所有的6后的数字
num = 2**100
without6 = ''
for digit in str(num):
    if digit == '6':
        pass
    else:
        without6 += digit
print("2**100 is: %d nwithout 6 is: %s"  % (num, without6))
 
2**100 is: 1267650600228229401496703205376 
without 6 is: 12750002282294014970320537
 
程序结构 
函数 
 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
 
 函数能提高应用的模块性，和代码的重复利用率
 
 Python提供了许多内建函数，比如print()
 
 开发者也可以自己创建函数，这被叫做用户自定义函数
 函数定义语法：
  
def functionname(parameters): 
   “函数_文档字符串” 
   function_suite 
  return [expression] 
# 定义一个求n！的函数
def fact(n):
    result = 1
    for i in range(1,n+1):
        result = result * i
    return result
 
可选参数以集合的方式出现在函数声明中并紧跟着必选参数，可选参数可以在函数声明中被赋予一个默认值。已命名的参数需要赋值。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明
函数可以返回一个元组（使用元组拆包可以有效返回多个值) 
# intp 和 stringp是可选参数，它们有默认值
# 如果调用于fun_example 时只指定一个参数，那么intp缺省为0 , stringp 缺省为 A default string.
# 如果调用fun_example 时指定了前面两个参数，stringp 仍缺省为A default string。
# Listp是必备参数，因为它没有指定缺省值。
def fun_example(listp, intp=0, stringp="A default string"):
    "这是一个略微复杂函数的例子，有关函数的说明文档可以写在这里"
    listp.append( "A new item" )
    intp += 1
    return listp, intp, stringp

my_list = [1,2,3]
my_int = 10
v1,v2,v3= fun_example(my_list,my_int)
print(v1)
print(fun_example(my_list,my_int))
print(my_list)
 
[1, 2, 3, 'A new item']
([1, 2, 3, 'A new item', 'A new item'], 11, 'A default string')
[1, 2, 3, 'A new item', 'A new item']
 
# 打印函数的帮助文档信息
fun_example.__doc__
 
全局变量与局部变量 
全局变量在函数之外声明局部变量在函数内容声明
函数参数也是局部变量，不需要在函数内部重复定义!!!
全局变量可以不需要任何特殊的声明即能读取，但如果想要修改全局变量的值，就必须在函数开始之处用global关键字进行声明，否则Python会将此变量按照新的局部变量处理（请注意，这点很容易被坑) 
number = 5
def func1():
    print(number)#函数内部未声明，访问全局变量
func1()
print(number)
 
5
5
 
number = 5
def func2():
    number = 3
    print(number)#函数内部声明，访问局部变量
func2()
print(number)
 
3
5
 
number = 5
def func2():
    global number
    number = 3 #这是全局变量
    print(number)#函数内部声明全局变量，访问全局变量
func2()
print(number)
 
3
3
 
类 
类(Class)用来描述具有相同的属性和方法的对象的集合
它定义了该集合中每个对象所共有的属性和方法
对象是类的实例 
class ClassName: 
   ‘类的帮助信息’ #类文档自负串 
   class_suite #类体 
class_suite由类成员，方法，数据属性组成 
#定义一个叫做DeepLearner的类
class DeepLearner(object):
    'DeepLearner是深度学习者的类，这是有关这个类的帮助文档'
    # LearnerCount变量是一个类的属性，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用DeepLearner .Llearnercount访问
    learnerCount = 0
    # _init_()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
    # 类的方法与普通的函数只有一个特别的区别—它们必须有一个额外的第一个参数名称，按照惯例它的名称是 self
    # seLf代表类的实例，参数seLf在定义类的方法时是必须要的，虽然在调用时不必传入相应的参数
    def __init__(self, name,schoolName) :
        self.name = name
        self.schoo1Name = schoolName
        DeepLearner.learnerCount = DeepLearner.learnerCount + 1
    def getName( self):
        return self.name
    def getSchoo1Name( self):
        return self.schoolName
    def displayCount(self):
        print("Total DeepLearner count is %d" % DeepLearner.learnerCount)
    def displayLearner(self):
        print("Name: %s, School: %s" % (self.name,self.schoolName))
 
#打印类的帮助文档信息
print(DeepLearner.__doc__)
 
DeepLearner是深度学习者的类，这是有关这个类的帮助文档
 
#实例化类其他编程语言一般用关键字new，但在Python中并没有这个关键字
#新建一个对象
newLearner1 = DeepLearner('giggle','Zhejiang University')
newLearner2 = DeepLearner('sherry','Zhejiang University of Technology')
 
# 使用点号 . 来访问对象的属性和方法
print(newLearner1.learnerCount)
newLearner1.displayCount()
 
2
Total DeepLearner count is 2
 
文件 
Python针对文件的处理有很多内建的函数库可以调用 
#写文件
with open( "test.txt", "wt" ) as out_file:
    out_file.write("该文本会写入到文件中n看到我了吧")
#读文件
with open( "test.txt", "rt" ) as in_file:
    text = in_file.read()
print(text)
 
异常 
Python中的异常由try-except [exceptionname]块处理 
def except_function():
    try :
    #故意除零
        10 / 0
    except ZeroDivisionError: 
        print("发生除零异常啦.")
    else:
    #正常情况.
        print ("一切正常啦.")
        pass
    finally:
    #无论是否发生异常都将执行最后的代码
        print ( "final1y必须被执行，不管有没有发生异常.")
 
except_function()
 
发生除零异常啦.
final1y必须被执行，不管有没有发生异常.
 
如果不知道发生什么异常，可以 except: 表示抓取所有异常 
导入外部库 
外部库可以使用import [libname]关键字来导入 
可以用from [libname] import [funcname]来导入所需要的函数 
import random
from time import time
import numpy as np
import matplotlib.pyplot as plt #绘图模块

randomint = random.randint(1,100)
print(randomint)

startTime=time()
print(startTime)
 
#直接采用np生成等差数列的方法，生成100个点，每个点的取值在-1~1之间
x_data = np.linspace(-1,1,100)
# y = 2x +1
y_data = 2* x_data + 1.0
 
#在Jupyter中，使用matplotlib显示图像需要设置为 inline模式，否则不会显示图像
%matplotlib inline
plt.figure()
plt.scatter(x_data,y_data)#画出随机生成数据的散点图
 
#显示运行总时间 秒为单位
duration = time()-startTime
print(duration)
 
获取帮助信息 
如果想知道一个对象(object)是如何工作的，可以调用help(对象)!另外还有一些有用的方法， 
dir()会显示该对象的所有方法，还有会显示其文档: 
#获取整形的所有方法
dir(1)
 
help(int)
 
a = 12345
a.__neg__()
 
打.后加tab键获取自动填充放方法选择

第一章 TensorFlow基础——python语法（三）

Python相关栏目本月热门文章