python入门篇

python入门篇1

一、了解python

python 不仅易于使用，而且还是一门完整的编程语言。与 Shell 脚本或者批处理文件相比较， python 为编写大型程序提供了更多的结构和支持。 python 还内置支持高级的数据结构类型，例如：灵活的数组和字典。

为了方便重用 python 程序， python 允许将程序分割为不同的模块。模块提供了文件 IO 、系统调用、 Socket 支持和类似
Tk 的用户图形界面工具包接口。

python 具有的三个好处：
1.你可以使用一条语句表达复杂的高级数据结构操作；
2.语句组使用缩进代替开始或者结束大括号；
3.变量或参数无需声明。

1.1python 命名规则

变量名的命名规则如下：
（1）变量名只能是字母、数字或下划线的任意组合；
（2）变量名的第一个字符不能是数字；
（3）python 关键字不能声明为变量名。
python 关键字主要有：

and, as, assert, break, class, continue, def, del, elif, else, except,
exec, finally, for, from, global, if, import, in, is, lamba, not, or,
pass, print, raise, return, try, while, with, yield

二、 python 解释器及常见类型

python 解释器类似于 Unix shell ：当使用终端设备 tty 作为标准输入调用时，它交互的解释并执行命令；当使用文件名参数或以文件作为标准输入调用时，它读取文件并将文件作为脚本执行。

调用命令格式：python -m module [arg]…

使用脚本文件时，经常会运行脚本然后进入交互模式，主要通过在脚本之前加上 -i 来实现。

从终端设备读取命令时，称解释器工作为交互模式。这种模式下根据主提示符来执行，主提示符（又称为“输入”）通常标识为三个大于号 >>>，继续的部分被称为从属提示符（又称为“输出”），有三个点标识 ... 。

注意：在练习中遇到的从属提示符表示你需要在最后多输入一个空行，解释器才能知道这是一个多行命令的结束。

注释以 # 字符起始，直至实际的行尾。

2.1 python 之简单计算

括号用于分组，其他同 C 语言类似，除法永远返回一个浮点数。如果要使用 floor 除法，得到整数结果，可以使用 // 运算符，计算余数使用 % ，使用 ** 运算符计算幂乘方。样例如下：

print(17 / 3)

print(17 // 3)

print(17 % 3)

print(5 ** 2)

print(2 ** 7)

结果如下：

注意：变量在使用前必须赋值，否则会出错。可以同时给多个对象指定赋值，如：a,b,c = 1,2,3；一个变量可以通过赋值指向不同类型的对象。整数和浮点数的混合计算中，整数会自动转化为浮点数。

2.2 python之字符串

字符串可以用单引号或双引号标识，特殊字符可以用来反斜杠 \ 转义。虽然可能和输入看上去不太一样，但是两个字符串是相等的。如果字符串中只有单引号而没有双引号，就用双引号引用，否则使用单引号引用。

如果遇到带有反斜杠的字符被当作特殊字符，可以使用原始字符串，
解决方法1：在第一个引号前面加上一个 r。字符串文本能够分成多行，一种方法是使用三引号："""…"""或者
‘’’…’’’。行尾换行符自动包含到字符串中，但是可以在行尾加上反斜杠来避免这个行为。

注意：字符串可以有 + 操作符连接，由 * 表示重复，数字在前表示重复次数。如果你想连接多个变量或者连接一个变量和一个字符串文本，使用 +。
字符串常见操作：

1. +：字符串连接；
2. *：重复输出字符串；
3. [ ]：通过索引获取字符串中的字符；
4. [ : ]：截取字符串中的一部分；
5. in：成员运算符，如果字符串中包含给定的字符返回true；
6. not in ：成员运算符，如果字符串不包含给定的字符返回true；
7. %：格式化字符串。

字符串也可以检索，类似于C语言，字符串的第一个字符索引为0。Python没有单独的字符类型，一个字符就是一个简单的长度为1 的字符串。索引也可以是负数，这将导致从右边开始计算。请注意 -0 实际上就是0，所以它不会导致从右边开始计算。
除了索引，还支持切片。索引用于获得单个字符，切片让你获得一个子字符串。

word = 'Python'

print(word[0])

print(word[5])

print(word[-1])

print(word[-2])

print(word[-6])

print(word[0:2])

print(word[2:5])

结果如图所示：

注意：包含起始的字符，不包含末尾的字符，使得 s[:i]+s[i:]===s 。
字符串常见操作：

1. isalnum()：检查字符串是否包含一个字符或者所有字符都是字母或者数字，是返回TRUE否则返回FALSE。
2. isalpha()：检查字符串是否包含一个字符或所有字符都是字母，是返回TRUE。否则返回FALSE。
3. isdigit()：检查字符串是否只包含数字。
4. lstrip()：去掉字符串左边的空格。
5. rstrip()：去掉字符串右边的空格。
6. split(str="",num=)：截取字符串。

切片的索引有非常有用的默认值，切片时的索引是在两个字符之间，左边第一个字符的索引为0，而长度为 n 的字符串其最后一个字符的右界索引为 n 。我对 s[i:j] 的理解 i , j 均为正数时， i 默认从字符串的最左侧开始， j 默认是字符串的最右侧，此时，字符串从0开始数； i , j 均为非正数时，字符串顺序左右向左一次减小，例如0，-1，-2，-3等等， i 默认为0， j 默认为 -n 。
切片是从 i 到 j 两个数值标示的边界之间的所有字符。对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。具体事例如下：

word = 'Python'
#s[:i]+s[i:]===s
print(word[:2]+word[2:])

print(word[:5]+word[5:])
#the first index omitted defaults to zero
print(word[:2])
#the second index omitted defaults to the size of the string
print(word[3:])
#characters from the second-last to the end
print(word[-2:])

结果如下所示：

python 字符串不可以更改，因为字符串不可变，导致赋值给字符串索引的位置会出错。如果需要一个新的字符串，可以重新设置一个变量利用 + 将其组合在一起。

（1）去空格、特殊符号或头尾指定字符应用实例
str.strip()：去除字符串开头和结尾的空白符，包括 \n,\t,\r 等；strip.strip(chars) 表示去除字符串开头和结尾指定的 chars 字符序列，只要有就删除。

#str.strip()
b='\t\ns\tpython\n'
print(b.strip())
#str.strip(chars)
c='16\t\ns\tpython\n16'
print(c.strip('16'))
#str.lstrip()
d="  python   "
print(d.lstrip())
#str.rstrip()
print(d.rstrip()+"***")

结果如下：

字符串大小写转化操作：
str.lower()：将字符串全部转化为小写字母。
str.upper()：将字符串全部转化为大写字母。
str.swapcase()：将字符串中的大小写互换。
str.capitalize()：返回一个只有首字母大写的字符串。
分割：

import string
#string.capwords(str):每个单词首字母大写 
print(string.capwords('Sharp tools make good work.'))

#string.capwords(str,args):每个单词以args后的字母大写
print(string.capwords('Sharp tools make good work ,too.','oo'))

str2="www.baidu.com"
print(str2.split('.'))
print(str2.split('.')[0])
#s.split(str,num) str:分隔符，num:分割 num+1 个子字符串
print(str2.split('.',1))
s1,s2,s3=str2.split('.',2)
print(s1+'\t'+s2+'\t'+s3)

wangzhi="hello world!<[www.google.com]>byebye"
print(wangzhi.split('[')[1].split("]")[0])

结果如图所示：


str.partition()：根据指定的分隔符将字符串进行分割，返回一个人包括三个元素的元组。
实例：

str="http://www.xinhuannet.com/"
str1=str.partition("://")
print(str1)
str2=str1[2].split('/')[0]
print(str2)

结果如下：

（2）字符串搜索与替换应用实例

1. str.find(substr [, start [, end ] ])：返回字符串中指定范围第一次出现的 substr
   的第一个字母的标号，下标是从0开始计算；如果字符串中没有 substr 则返回-1。
   start ：代表开始查的开始位置；end：代表查找的结束位置。
2. str.index(substr [,start, [end] ]) ：在字符串中查找子字符串substr第一次出现的位置。
3. str.replace(oldstr, newstr [, count]) ：把字符串中的 oldstr 字符串替换成 newstr 第一次出现的位置，未找到则抛出异常。
4. str.count(substr[, start, [end] ] )：统计字符串中的子串出现的次数，如果不指定开始位置和结束位置，表示从头开始统计到尾。

#str.find()
s='He that can have patience, can have what he will.'
s1=s.find('can')
print(s1)
s2=s.find('can',9,30)
print(s2)

#str.index(substr [,start, [end] ])
s3=s.index("good")
print(s3)

#str.replace(odstr,newstr[, count])
ss='aababababaff56sddfdbabababaddaa'
ss1=ss.replace('ab','* *')
print(ss1)
ss2="This is a cat.This is my picture."
ss3=ss2.replace("is","was")
print(ss3)


sss="aadgxdfadfaaadaggaa"
sss1=sss.count('aa')
print(sss1)

结果如下：

2.3 python 之 number

python 包括4种数字数据类型，主要有：整型（int），浮点型（float），布尔型（bool），复数型（complex）。
常用的数学函数：

abs(x)：返回绝对值。 math.ceil(x)：返回数值的上入整数。
exp(x)：返回 e 的 x 次幂。
math.floor(x)：返回数字的下舍整数。
max(x,y,z,…)：返回给定序列的最大值。
min(x,y,z,…)：返回给定序列的最小值。
pow(x,y)：返回x的y次方运算后的值。
math.sqrt(x)：返回数字 x的平方根
round(x,n)：对 x 值进行四舍五入，n 为保留小数点后的位数。

三、循环语句

3.1 for 循环

python的循环有两种：for....in 和 while 。
第一个样例：使用一个范围让 for ，进行循环。

#the value of i starts from 0 to 4
for i in range(5):
    print(i)

第二个样例：range(i,j,k) i 为起始值，j 为结束值，k 为步距。从0开始到10结束，每次加3。

for i in range(0,10,3):
    print(i)

第三个样例：将每个字母分隔开输出。

name="chengdu"
for x in name:
    print(x,end="\t")
#common usage
a=["aa", "bb", "cc", "dd"]
for i in range(len(a)):
    print(i,a[i])

3.2 while 循环

第一个样例：求1到100的和。

i=1
count=0 
while i<=100:
    count += i
    i += 1
print("1到100的和：%d"%count)

while 可以和 else 一起连用 ，例子如下：

sum=0
n=100
while n>0:
    sum +=n
    n -= 1
else:
    print(n,sum)
print(sum)

3.3 break 和 continue

break 跳出 for 和 while 的循环体，停止当前循环； continue 跳过当前循环，直接进行下一轮循环；pass 是空语句，一般用作占位语句，不做任何事情。

四、列表、元组、字典

4.1 列表

python 通常用复合数据类型表达其他的值。最通用的就是 list ，格式为中括号之间的一系列逗号分隔的值，例如 List1=[ a , b , c , d , e ] ，可以进行索引和切片，并且也支持 + 。列表是可变的，允许修改元素。列表内允许嵌套列表，列表方法可以很方便作为一个堆栈来使用，堆栈作为特定的数据结构，特点是后进先出。
把列表当作队列使用，特点先进先出，这样使用效率不高。缺点：为了一个元素，要移动整个列表中的所有元素。
列表类似于数据结构中的数组，列表中元素的类型可以不相同，支持数字、字符串或包含列表。
列表要用 [] ，用“,”分隔开元素列表。索引值以0开始，-1为从末尾开始的位置。列表使用 ”+“ 进行连接，使用 ”*“ 表示重复。

4.1.1 列表增加：

案例：

#定义一个空的列表
namelist=[] 
#列表中可以存储混合类型
testlist=[1, "xiangzhang", "小王"]
print(testlist)
#len()可以得到列表的长度
length=len(testlist)
print(length)

nametemp = input("请输入添加学生的姓名：")
testlist.append(nametemp)
for name in testlist:
    print(name)
print(testlist)
a=[1,2]
b=[3,4]
a.append(b)
print("简单添加b到a中，则结果如下：")
print(a)

a.extend(b)
print("将 a 进行扩展，结果如下：")
print(a)

结果如下所示：

numlist=[0,1,2]
#insert(i,e),i指下标，e指插入元素
numlist.insert(2,7)
for num in numlist:
    print(num)

4.2.2 列表删除

案例1：

movies=["美人鱼", "机械师2", "速度与激情", "指环王", "穹顶之下"]
print("删除前，电影名：")
print(movies)

#在末尾删除一个元素
del movies[len(movies)-1]
print("删除后，电影名：")
print(movies)

结果如下：

movies=["美人鱼", "机械师2", "速度与激情", "指环王", "穹顶之下"]
print("删除前，电影名：")
print(movies)

#弹出最后一个元素
movies.pop()
#移除一个元素，如果有重复的内容，只删除找到的第一个。
movies.remove("指环王")
print(movies)

4.2.3 列表修改

主要指修改指定下标的内容。

movies=["美人鱼", "机械师2", "速度与激情", "指环王", "穹顶之下"]
movies[1]="机械师I"

4.2.4 列表查找

查找方式一：用 in 。案例如下：

#查： [in , not in]
namelist=["小王", "小李", "小艾", "小陈"]
findName = input("请输入你要查找的学生姓名：")

if findName in namelist:
    print("在学员名单中找到了相同的名字")
else:
    print("没有找到")

结果如下所示：

查找方式二：用 index 查找，
查找方式三：用 count 。
案例如下所示：

alist=["a", "b", "c", "a", "b"]
#find a from 1 to 4,范围左闭右开
print(alist.index("a",1,4))
print(alist.count("a"))

结果如下所示：

列表常用的函数：

reversed()：反转一个序列对象，将其元素从后向前颠倒构建成一个迭代器。 sorted()：排序一个新序列，不改变原始的序列。
zip()：打包函数，返回一个列表，其第一个元素是it0,it1…这些序列元素的第一个元素组成的一个元组，其他元素依次类推。
enumerate():枚举函数，将一个可遍历的数组对象组合为一个索引序列，序列中每个元素构成一个元组。
shuffle()：可以实现随机排列列表中的元素。

案例如下：（代码使用 Jupyter Notebook 该软件写的）

a=[9,8,7,6,5,4,3,2,1,0]
#将列表a进行反转
list(reversed(a))
#排序，默认从小到大
sorted([46,15,-12,9,-21,30])
#排序之前先进行取绝对值，再进行排序。
sorted([46,15,-12,9,-21,30],key=abs)
#默认从小到大排序
sorted(['bob','about','zoo','Create','Direction'])
#按小写进行排序
sorted(['bob','about','zoo','Create','Direction'],key=str.lower)
#按小写反向排序
sorted(['bob','about','zoo','Create','Direction'],key=str.lower,reverse=True)
#zip()打包函数，返回一个列表，其第一个元素是it0,it1...这些序列元素的第一个元素组成的一个元组，其他元素依次类推。
a,b,c=[1,2,3],['a','b','c'],[4,5,6,7,8]
list(zip(a,b))
list(zip(c,b))

str1='abc'
str2='123'
list(zip(str1,str2))

#enumerate():枚举函数，将一个可遍历的数组对象组合为一个索引序列，序列中每个元素构成一个元组
#默认情况下，下标从0开始
seasons=['Spring','Summer','Fall','Winter']
list(enumerate(seasons))
#设置下标从1开始计数
list(enumerate(seasons,start=1))
list1=[2,3,7,1,6,12]
import random
#shuffle()：可以实现随机排列列表中的元素
random.shuffle(list1)
list1

4.2.5 列表常用方法

常见列表方法：

list.extend(L) ：将一个给定列表中的所有元素都添加到另一个列表中。
list.insert( i , x )：在指定位置插入一个元素， i 表示插入到那个位置，x 表示要插入元素。
list.remove(x) ：删除列表中值为 x的第一个元素。
list.pop([i]) ：删除列表中指定位置元素，默认删除最后一个。
list.clear()：删除所有元素。
list.index(x) ：返回第一个值为 x 的元素的索引。
list.count(x) ：返回 x在列表中出现的次数。
list.sort() ：对列表中的元素进行排序。
list.reverse() ：倒排列表中的元素。
list.copy()：返回列表的一个浅拷贝。

具体实例如下所示：

4.2.6 列表生成（推导）式

列表生成式是利用其他列表创建新列表的一种方法，格式为

[ 生成列表元素的表达式 for 表达式中的变量 in 变量要遍历的序列 ] [ 生成列表元素的表达式 for 表达式中的变量
in 变量要遍历的序列 if 过滤条件]

注意：

1. 要把生成列表元素的表达式放到前面，执行时，先执行后面的 for 循环。
2. 可以有多个 for 循环，也可以在 for 循环后面加个 if 过滤条件。
3. 变量要遍历的序列，可以是任何方式的迭代器。

a=[1,2,3,4,5,6,7,8,9,10]
[ 2*x for x in a]

[ 2* x for x in range(1,11)]

[2*x for x in range(1,11)  if x%2==0]

结果如下图所示：