python 入门学习

最近在某学习网站，学习了一下python，记录一下，仅做学习用途，侵权删除。

1. 认识python

1.Python是一个动态的解释性语言。什么意思呢，就是说在运行之前不会对代码做翻译工作，计算机会直接在它运行时一边理解，一边执行，一边判断是否有语法错误。

2.Python 是不需要说明类型的：变量，参数，函数等等都无需说明类型。

3.Python分为两个版本：2和3 ，我们主要学习2, 版本3目前还不稳定。

• 程序1

：认识基本操作：变量赋值，输出变量

a=6
print a
b="hello world"
print b
a=b
print a,b

输出：
6
hello world
hello world hello world
既然能够直接赋值（=被重载）那么+ * - / 也被重载了吗？

a = 'a'
b = 'b'  
print a+b
print a*3+b 

输出ab 和 aaab ，但是/ 和 - 无法通过编译 ，所以我们可以发现 * 和+ 是被重载过，但是- 和 / 并没有被重载。

关于 len和str

a = 'China'
a_len=len(a) 
print 'length of a is ' + str(a_len)

输出： length of a is 5 可以发现str(int)其实是将一个int 类型的数字转换为了一个字符串的形式，而len 可以看成简化了语法的strlen

• 程序2

： 询问输入，并将输入值付给name，括号内是提示内容（会打印出来）

name=raw_input('What is your name:')  
print 'Your name is '+name

• 程序3

：默认的（向下）取整除法（被除数、除数都是整数，结果也是整数） ，精确除（被除数、除数有一个是小数，结果也是小数）

print 3/2
print 3/2.0
print 2./2

输出： 1、 1.5、 1.0

我们当然也可以全部都使用精确的除法，从版本3里面导入包，这样进行的全部除法都是精确除， 如果我们仍想使用取整除可以用//运算符。

from __future__ import division
print 3 / 2
print 3.0 / 2.0
print 2. / 2.
print 3//2

输出： 1.5 、 1.5 、 1.0 、 1

小测验

a = '10'
b = 10
c = str(len(a) + b)
a = len(a * b)
b = b + a

很简单 可以知道 ：最终 a=20 b=30 c=’12’

据说一个很标准的程序
if….定义了一个一个很标准的程序执行入口

def main():
    print 'Hello World'

if __name__ == '__main__':
    main()

那么函数又如何使用呢

def max_pow(a, b): 
    if a > b:
        pow_ab = a ** b
        return pow_ab
    pow_ba = b ** a
    return pow_ba

从上面函数得到的知识：
1.每一行的语句开头空格数一致，称行缩进，相同缩进的行被认为在同一个层次。也就是说 if a>b: 后面隐藏{} ，而这里面的东西必须拥有相同的行缩进咯？同理，max_pow(a, b): 也是一样咯？
对逻辑相同的语句进行组织时应使用4个空格。
同时极为反对使用tab 进行缩进，因为在不同的编译器上有不同的处理方式。

2.关键字 def ：定义函数的名称
3. ** 是什么东西呢，我们不妨写个东西验证一下

def main():
    print 2 ** 3
    print 2 ** 4
    print 3**4
if __name__ == '__main__':
    main()

输出 8 、 16、 81 所以我们可以大胆猜想 ** 相当于 指数（2^4=2*2*2*2）

如果我们遇到我们不会的函数，或者关键字，是可以在程序里查看如何运用的。

import sys 
help(len)
print dir(sys)

help (sys.exit)
help('china'.split)
print dir(list)

我们可以去看len函数、 和list下所有被定义的函数方法列表？？（大概就是help (sys.exit) 和 help(‘china’.split)这两句话咯？）

split函数使用：

s ="www.google.com"   
print s.split('.')               
print s.split('.',1)    
print s.split('.',-1)   

print s.split('.')[1]      
print s.split('.',1)[-1]   

s1,s2,s3=s.split('.',2)       
print s1
print s2
print s3

输出：
[‘www’, ‘google’, ‘com’] 使用. 分割最多次
[‘www’, ‘google.com’] 使用. 分割1次
[‘www’, ‘google’, ‘com’] 使用. 分割最多次
google 使用. 分割最多次 之后的第1部分
google.com 分割1次之后的倒数第一部分，同理如果-2则是倒数第二部分
www
google
com

经典样例：

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

输出：
www.google.com
[‘www’, ‘google’, ‘com’]

小测验
a+b+c

s=raw_input()
a,b,c=s.split(' ')
print int(a)+int(b)+int(c)

或者

a,b,c=(int(x) for x in raw_input().split(' ') )
print a+b+c

首先我们可以知道raw_input是输入的时候呢是一个字符串型的输入，我们需要将其转换为数字来计算。然后我们可以通过第二种方法来学习下for的用法

字符串
我们引用字符串的时候用单引号或者双引号都是可以的，但如果在字符串中存在引号，那么双引号包裹的字符串可以直接引用单引号，反之依然，否则需要使用转义字符 : \’ \”
一个字符串可以分成多行写，但需要在末尾加上\

a = 'This is a string\
that is so good to \
let you to understand'

概念： 一个字符串被创建之后不可以被做出任何改变
因此，我们在字符串的计算过程中实际上是在不断地创建新的字符串。
比如a=’b’+’c’ 即创建了一个新的字符串’bc’然后a指向他。
访问某个字符和c++一样，都是用[] 索引都是从0开始

在一个字符串前+r有什么效果？以及lower() upper()函数

a = 'In\na line'
b = r'In\na line'
print a
print b
print a.lower()
print b.upper()

输出：
In
a line
In\na line 所以+r可以让换行失效？准确的说是让转义字符失效
in
a line
IN\NA LINE 而显然 lower和upper函数是将字符串转换为大小写

几个函数：是否全部为字母、数字、空格(isspace)、是否以…开头 、是否以…结尾。

s = 'HelloabcdWorld'
print s.isalpha()
print s.isdigit()
print s.startswith('Hello')
print s.endswith('World')

输出 True 、False 、True、True

[]内快速使用位置索引

tower = 'abcdefg'
print tower[1:4]
print tower[3:]
print tower[:-2]

输出：
bcd 说明这个区间是[ l,r )
defg
abcde

replace 函数： 两个参数，将原字符串中所有含有第一个参数的子字符串都替换为第二个参数：

weather = 'rainy day'
bag = 'nothing in the bag'
if weather.find('rain')!=-1:
    bag=bag.replace('nothing','umbrella')
print bag

输出：umbrella in the bag

不同类型的变量对应的输出方式： 整数 –%d 小数—%g 字符串–%s

name = 'Wangmu Niangniang'
age = 9000
height = 1.73
print name + ' is a ' + str(age) + '-year-old woman with height ' + str(height)
print '%s is a %d-year-old woman with height %g' %(name,age,height)

小测验：
把一个字符串里面的所有的空格换成%20

from __future__ import print_function
s = raw_input()
l = len(s)
p = 0
while (p < l):
    if (s[p]==' '):
        print('%20', end='')
    else:
        print(s[p], end='' )
    p = p + 1

用print函数之前，一定要使用 from future import print_function 定义print的函数。

Python的结构：
1列表的定义与访问

list=[100,23,45]
print list[0]
print list[1]
print list[2]
print len(list)

2.list 的添加与连接 自行感受理解：append 与 extend函数,insert函数 与index函数

hello = ['hi', 'hello']
world = ['earth', 'field', 'universe']
hello.append('nihao')
print hello
hello.extend(world)
print hello

hello2 = ['hi', 'hello']
hello2.insert(0,'nihao')
print hello2
print hello2.index('hi')

输出：
[‘hi’, ‘hello’, ‘nihao’]
[‘hi’, ‘hello’, ‘nihao’, ‘earth’, ‘field’, ‘universe’]
[‘nihao’, ‘hi’, ‘hello’]
1

3.删除： 比较remove和pop函数

hello = ['nihao', 'hi', 'hello', 'a', 'b', 'c']
hello.remove('nihao')
print hello
hello.pop(0)
print hello
hello.pop(1)
print hello

输出：
[‘hi’, ‘hello’, ‘a’, ‘b’, ‘c’]
[‘hello’, ‘a’, ‘b’, ‘c’]
[‘hello’, ‘b’, ‘c’]
我们通过其他的尝试可以发现：pop参数只能为索引位置，且这个参数必须在索引范围内， 同理 如果remove 的参数在list中找不到，也会报错。
有一个很尴尬的地方： print hello.pop(0) 输出是：列表内的第一个元素，而不是pop完之后的整个列表。。。

4.另一种连接方式 join函数 ： 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
manager = 'tuotatianwang,taibaijinxing,juanliandajiang'
manager_list=manager.split(',')
print manager_list
new_manager =' '.join(manager_list)
print new_manager
输出：
[‘tuotatianwang’, ‘taibaijinxing’, ‘juanliandajiang’]
tuotatianwang taibaijinxing juanliandajiang

5.sort的使用

numbers = [1, 4, 2, 3, 8, 3, 0]
print sorted(numbers)
print sorted(numbers,reverse=True)

numbers.sort()
print numbers
x=numbers.sort()
print x

输出：

[0, 1, 2, 3, 3, 4, 8]
[8, 4, 3, 3, 2, 1, 0]
[0, 1, 2, 3, 3, 4, 8]
None // 所以这个地方值得注意下，list.sort()这个语句是没有返回值的. BBBBBBUT！！！ sorted(list)返回排序完成后的list

sort的自定义关键字使用：

def china_first(item):
    if item == 'China':
        return 0
    else:
        return len(item)
country = ['jp', 'China', 'USA', 'Thai']
print sorted(country)
print sorted(country,key=len)
print sorted(country,key=china_first)

输出：
[‘China’, ‘Thai’, ‘USA’, ‘jp’]
[‘jp’, ‘USA’, ‘Thai’, ‘China’]
[‘China’, ‘jp’, ‘USA’, ‘Thai’]

元组的使用：有一点类似struct 结构提，他可以包含多个数据，但是在python里面：用法和list 又有某些相同。

tuple = (1, 2, 'hi')
print len(tuple)
print tuple[2]
#tuple[2]='bye' 
tuple=(1,2,'bye')
print tuple

tuple[2]=’bye’ 在元组里面这种语句是不可以直接使用的，我们想要修改某个值就只能重新去创建一个新的元组。
输出：
3
hi
(1, 2, ‘bye’)

小测验
输入一行 k 个用空格分隔开的整数，依次为 n1, n2 … nk。请将所有下标不能被 3 但可以被 2 整除的数在这些数字原有的位置上进行升序排列，此外，将余下下标能被 3 整除的数在这些数字原有的位置上进行降序排列。
输出包括一行，与输入相对应的若干个整数，为排序后的结果，整数之间用空格分隔。
样例输入
1 5 4 3 10 7 19
样例输出
1 3 7 5 10 4 19
说实话，我这代码写得有点丑的啊。。。bytheway，元组的排序是默认顺序，和pair一样

from __future__ import print_function
a = raw_input().split(' ')
a.insert(0,-1)
ans=a
for x in ans:
    p=ans.index(x)
    ans[p]=int(ans[p])
s1=[]
s2=[]
for i in a:
    p=a.index(i)
    if(p>0):
        if(p%3==0):
            s1.append([int(a[p]), p])
        else:
            if(p%2==0):
                s2.append([int(a[p]), p])
s1.sort(reverse=True)
s2.sort()
p=1
for x in s1:
    ans[p*3]=x[0]
    p+=1
p=1
for x in s2:
    while((p*2)%3==0):
        p+=1;
    ans[p*2]=x[0]
    p+=1;
for i in ans:
    p=ans.index(i)
    if(p>0):
        if(p!=len(ans)-1):
            print (ans[p],end=' ')
        else:
            print (ans[p],end='')

python 里面的map(pair) —— 键值： 可以

bat = {} 
bat['b'] = 'baidu' 
bat['a'] = 'alibaba' 
bat['t'] = 'tencent'
print bat
print bat['a']
bat['a']='amazing'
print bat['a']
print 'b' in bat
print 'x' in bat
print 'baidu' in bat
print bat.keys()
print bat.values()
print bat.items()

输出：
{‘a’: ‘alibaba’, ‘b’: ‘baidu’, ‘t’: ‘tencent’}
alibaba
amazing
True
False
False
[‘a’, ‘b’, ‘t’]
[‘amazing’, ‘baidu’, ‘tencent’]
[(‘a’, ‘amazing’), (‘b’, ‘baidu’), (‘t’, ‘tencent’)]

字典的遍历

bat = {'a': 'alibaba', 'b': 'baidu', 't': 'tencent'}
for value in bat.values():
    print value
for key in bat:
    print key
for k,v in bat.items():
    print k,'>',v

字典另外的输出方式

boss = {}
boss['name'] = 'robin'
boss['age'] = 45
boss['height'] = 1.78
print 'The boss named %(name)s is %(age)d-year-old and %(height)g tall.'%boss

输出：
The boss named robin is 45-year-old and 1.78 tall.

字典的删除操作，list的删除操作，

num = 6
list = ['a', 'b', 'c', 'd']
dict = {'a': 1, 'b': 2, 'c': 3}
del list[0]
del list[-2:]
print list
del dict['b']
print dict
del num
print num

输出：
[‘b’]
Traceback (most recent call last):
{‘a’: 1, ‘c’: 3}
print num
NameError: name ‘num’ is not defined

文件的使用

fd=open(‘1.txt’,’r’) 表示从某个文件中读取并且放入fd
fd.close() 用完之后关闭
fd=open(‘1.txt’,’rw’) rw表示既有读入的操作，也有写入操作

按行输出整个文件
f = open(‘filename’, ‘rU’)
for line in f: # 访问文件每一行
print line, # 打印每一行，加逗号可以不被额外添加换行

fd.write(‘sadafas’) 将某个字符串写入文件