Python 零基础学习笔记

1. 2**3=8 ** 代表指数
2. 变量名对大小写敏感
3. Python脚本以.py结尾命名。
4. 如果你不确定一个值具有什么类型，解释器可以告诉你。
   函数名是type。括号中的表达是被称为函数的实参（argument）。 此函数的结果是实参
   的类型。

>>> type('Hello, World!')
 <type 'str'>              #是字符串类型
>>> type(17)
<type 'int'>             #整型

注释：用#
5.模块
实现一定功能的Python脚本集合
引入模块 import 模块名
例如：引入math模块 import math
查看模块内容 dir（math）— 查看math模块中有哪些函数和元素

6. 输入：‘abc’*3
输出： ‘abcabcabc’
7. 123 and 456
答案为456
and不是位与。123评估为true，返回值就是and后面的一个。
123 or 456就返回123。
说到底跟and 和or的特性有关。
8. 输入 raw_input 函数
功能：读取键盘输入，将所有输入作为字符串看待
语法：raw_input([prompt])
[prompt]是提示符
若需要整型，需强制转换 如： x=int(raw_input(‘请输入x’)
9. 输出 print 关键
功能：将对象的值输出到控制台
1如何将多个对象输出到一行
Print xxx,xxxx,xxx,
之间用逗号隔开，逗号除了分隔的作用，还会输出一个额外的空格
2如何将输出多行
Print ‘hell0\nworld’
10. Elseif Python写作elif
11. While循环
While 循环语句条件:
缩进语句块
其余语句
12 Python的range()函数——通常用于for循环

   >>> range(1,5)  #代表从1到5(不包含5)
[1, 2, 3, 4]
>>> range(1,5,2)   #代表从1到5，间隔2(不包含5)
[1, 3]
>>> range(5)       #代表从0到5(不包含5)
[0, 1, 2, 3, 4]

如：

for num in range(1, max):

12. 函数
函数定义：
def（关键字） 函数名（参数）：

★ def A（arg1,arg2=2,arg3=3）:
arg2,arg3为缺省参数，当调用时没有给出时使用
可以这样调用：.
defaultParameters(10, arg3=10)
defaultParameters(arg3=10, arg1=10)
defaultParameters(10)

x = 1      //全局变量

def fun(x):
 x = 2    //局部变量

fun(x)
print x

答案：1
如果全局变量和局部变量同名，两个x并不相同，函数内部其实是对局部变量进行操作，而print x 打印的是全局
如果想在函数中对全局变量进行修改的话，必须加入一个关键字global
如：

x = 1      //全局变量

def fun(x):
    global x = 2    //表面对全局变量进行修改

fun(x)
print x

★ def prime(x):
pass #一个占位符，相当函数暂时还未实现

★ if x in (1,3,5,7):
表示当x在1,3,5,7时执行if语句
★ 调用随机函数：
import random
x=random.uniform(1,10)
表示产生1到10之间的随机数
★字符串
使用成对的单引号或者双引号括起来，或者三引号
S=’hello’
S=”hello”
S=’”hello
Word”’ //将回车格式也全部保留
长度： len(s)
拼接： name=s+’world’
重复：name*3
若输出hello’s world s=’hello \’ world’
判断一个字符串是否是另一个字符串的子串：

Name=’hello world’
‘hello’  in  name

返回：true
对大小写是敏感的
打印字符串：

S=’hello’
for c in s:
   print c

结果：
h
e
l
l
o
例子： 找出s一共有多少个元音字母

Def vowles_count(S):
        count=0
        for c in s:
           if c in ‘aeiouAEIOU’
             count+=1
        return count

 print vowles_count(‘hello world’)

★字符串索引
索引从0（前向）或-1（后向）开始
如‘hello world’
Forward index 0 1 2 3 4 5 6 7 8 9 10
h e l l o w o r l d
Backward
index -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
★索引不仅可以得到字符串中的一个字符，也可得到多个字符，也就是使用切片选择字符串的子序列
语法 ： [start：finish]
Start：子序列开始位置的索引值
Finish：子序列结束位置的下一个字符的索引值
如果不提供start或finish，默认start为第一个字符开始，finish为最后一个字符

  >>>s=’hello world’
  >>>s[6:10]
  ‘worl’
  >>>s[6: ]
  ‘world’
  >>>s[ :6]
  ‘hello ’

★获得逆序字符串

  >>>s=’spam’
  >>>s1=s[ : : -1]
  >>>print s
  maps

★字符串是不可改变的
一旦生成，内容不能变，不能根据索引改变字符串中内容
★字符串方法
1. replace(ord,new)生成一个新的字符串，使用new代替ord子串

>>>s=’hello’
>>>s=s.replace( ‘e’ , ’a’ )    #如果不重新赋值给s，则执行完replace()后原始串并不改变
>>>print s
hallo

1. find()
   在一个字符串中查找它的子串，并返回下标

  s=’hello’
  s.find(‘l’)

1. split
   对字符串进行切分，如果没有任何参数，就是在空格位置对原始字符串进行切分

  >>> s=’hello world’
  >>> s.split()
  [‘hello’ , ‘world’]

1. strip()
   功能就是去掉一个字符串开始和结尾的空格回车等等
   
   1. title()
      使字符串首字母大写，其他字母小写

★例子：人名游戏
读取人名列表文件names.txt,将每个人名转换为首字母大写，其他字母小写的格式
对文件进行操作：
打开文件
f=open(filename,mode)
第二个参数是打开的模式，但是模式只有r(只读，默认)，w(可写)等
按行读取文件内容
for line in f:
pass # 对文件每一行内容进行操作
关闭文件
f.close()
写文件
f.write(str)

f=open('e:\\names.txt','r') #第一个参数是文件的打开路径
for line in f:
    line=line.title()
    print line.title()
f.close()

例子：人名游戏
编写一个名为is_palindrome的函数，判断一个人名是否为回文
如：BOB是回文

f=open('e:\\names.txt','r')

def is_panlindrom(name):
    low=0
    high=len(name)-1

    while low<high:
        if name[low]!=name[high]:
            return False
        low+=1
        high-=1
    return True

for line in f:
    line=line.strip()

    if(is_panlindrom(line)):
        print line

f.close()

★ 字符串比较
使用字典序来比较
1. 首先比较两个字符串的第一个字符
2. 如果相同，则比较下一个字符
3. 如果不同，则字符串的大小关系由这两个字符的关系决定
4. 如果其中一个字符为空（较短），则其更小
★ 字符串格式化
format方法
如： >>>print “hello {} good {}”.format( 5 , ’DAY’ )
Hello 5 good DAY
括号的格式：
{field name:align width.precision type}
{域的名字：对其的方式（大于号表示向右对其，小于号向左对齐）占用的}

`>>>print ‘pi is { : .4f} ‘.format(math.pi)
pi is 3.1416    #4f 就是精度 4位并以浮点数形式
>>>print ‘pi is { :9 .4f} ‘.format(math.pi)
pi is     3.1416    #9.4f 就是占用9个字符 精度 4位并以浮点数形式

★正则表达式
判断一个人名是否满足下列模式
1. 判断name是否等于bob Name==’Bob’
2. Name是否以 Mi开头 name[:2]==’Mi’
3. 包含cha子串 ‘cha’in name
4. 包含c?a子串
5. 包含c*e子串
正则表达式用来描述字符串的模式
1. .表示任意字符串
2. \d+ 表示一系列数字
3. [a-z] 表示a到z所有字母，即表示一个小写字母
例如：判断一个人名是否含有C.A模式

import re  #正则表达式的缩写
f= open(‘names.txt’)
p=’(C.A)’
for line in f:
   name=line.strip()
   result=re.search(p,name)
   if result:
print ‘find in{} ‘ . format(name)
f.close()

★列表（list）
内建的数据结构，用来存储一系列的元素
如：lst=[5.4,’hello’,2] 存储三个内容5.4，‘hello’，2
lst 5.4‘hello’ 2
index 0 1 2
index -3 -2 -1
列表与字符串区别
相同点：
1. 索引 []
2. 切片 [ : ]
3. 拼接 + 和重复 *
4. 成员 in
5. 长度 len()
6. 循环 for
不同点：
1. 使用[]生成，元素之间用逗号分隔
2. 列表可以包含多种类型的对象，而字符串只能是字符
3. 列表内容是可变的 而字符串不可变
★列表的方法
1. append()
在list后追加一个新的元素
2. extend()
在列表后面追加一个新的列表
4. insert(插入位置，插入内容)
5. pop()
无参数，就是删除最后一个元素，并进行返回
加参数，就是删除参数下标
6. remove()
参数表示删除的内容
7. sort()
从小到大对列表进行排序
8. reverse()
逆序
例子：求输入20个数字的平均数

nums=[]
for i in range(20):
    nums.append(float(raw_input()))
s=0
for num in nums:
    s+=num
avg=s/20
print avg

1.  def f(l):
2.      l = [4, 5, 6]
3.      return l
4.        
5.  a = [1, 2, 3]
6.  a = f(a)
7.  print a[1]

输出：5

1.  def f(l):
2.      l[1] = [5]
3.      return l
4.        
5.  a = [1, 2, 3]
6.  f(a)
7.  print a[1]

输出：[5]

★ 排序
1.选择排序法
方法1：
<1.找到最小的元素
<2.删除它，然后将其插入相应的位置
<3.对于剩下的元素，重复1,2

lst=[1,24,21,33,45,56,3]

def select(lst):
    for i in range(len(lst)):
        min=i
        for j in range (i+1,len(lst)):
            if lst[j]<lst[i]:
                min=j
        lst.insert(i,lst.pop(min))

select(lst)
print lst

方法2：
<1 找到最小的元素
<2 和第一个元素进行交换
<3 重复1,2

def swap(lst,i,j):
    k=lst[i]
    lst[i]=lst[j]
    lst[j]=k

def select_v2(lst):
    for i in range(len(lst)):
        min=i
        for j in range (i+1,len(lst)):
            if lst[j]<lst[i]:
                min=j
        swap(lst,i,min)             

select_v2(lst)
print lst

2.冒泡排序

def bubble(lst):
    top=len(lst)-1
    is_exchange=True

    while is_exchange:
        is_exchange=False
        for i in range(top):
            if lst[i]>lst[i+1]:
                is_exchange=True
                swap(lst,i,i+1)
        top-=1

bubble(lst)
print lst

计算所有学生的平均分

Students=[[‘zhang’,84],[‘wang’,77],[‘li’,100],[‘zhao’,53]]
s=0
for stu in students
    s+=stu[1]
print float(S)/len(students)

★【列表解析】源列表创建新列表的简洁方法
如生成{x^2:x<{1…9}}

  Lst=[]
  for x in range(1,10):
     lst.append(x**2)
  print lst

用列表解析

Lst = [x**2 for x in range(1,10)]

计算所有学生的平均分用列表解析简化

print float(sum([x[1] for x in students))/len(stundets)

★用列表解析对所输入的数字x的因数求和
如：输入6，因数求和为12 因为1+2+3+6=12

sum([i for i in range(1,x+1) if x%i==0])

★对学生成绩进行排序

Students=[[‘zhang’,84],[‘wang’,77],[‘li’,100],[‘zhao’,53]]
students.sort()    #错误，输出结果是对人名进行排序，并不是成绩 
此时需要对sort（）中增加参数
student.sort(key=f,reverse=True)
def f(a):
    return a[1]
# reverse=True 表示按照逆序排列（从大到小）
# key可以等于一个函数

★更简便的方法是定义一个匿名函数lambda

  g=lambda x:x**2
            # x 代表参数
            # x**2代表返回值，将lambda函数复制给变量g
Students.sort(key=lambda x:x[1],reverse=True)

★元组
<1 元组即不可变的列表
1. 除了可改变列表的方法外，其他方法均适用于元组
2. 索引，切片，print，len()均适用
3. append，extend,del等不可用
<2 创建元组
S=1,’a’,3.14,True
或者s=(1,’a’,3.14,True)
<3 元组赋值
交换两个值
a,b=b,a
如：切分一个邮件地址

 name,domain=’car@hit.edu.cn’.split(‘@’)
   # split()从@切分，将car赋值给name，其余的赋值给domain

★字典
一系列键-值对，通过键查找值
创建字典：
<1 使用{}创建字典
<2 使用：指明，键：值对
如：dict={‘a’:123,’b’:345,’c’:435}
<3 键必须是不可变且重复，值可以是任意类型
访问字典：
<1 使用[]运算符，键作为索引
如：print dict[‘a’]
<2 增加一个新对
dict[‘d’]=2445
字典方法：

小例子：统计一个字符串中每个字母出现的次
<1 用列表解决

  s='ewhfoewfni'
  lst=[0]*26   #建一个列表，初始化有26个0，abcd..分别代表1,2,3,4.
  for i in s:
      lst[ord[i]-97]+=1  #ord转换为ascii码
  print lst

<2 用字典解决

s='ewhfoewfni'
d={}    #空字典
for i in s:
    if i in d:
       d[i]+=1
    else:
       d[i]=1
print d