python菜鸟教程基础入门

一、

1. 可以使用’\'来连接多行。但是有括号的则不需要

a=b+\
  c+\
  d
a1=['a',
    'b']

2. 引号可以是单，双，三引号均可

二、

1. python有5个标准类型：数字，字符串，列表，元组，和字典

2. 字符串

1. 获取某字符串的一段字符串可以使用[头下标，尾下标]

s='abcde'
s[1:5]
# 'bcde'
s+'rrr'#字符串加法
s
#bcderrr

3. 列表：Python中使用最频繁的类型

1. 列表用[]标识，支持[]截取，从左开始从0，从右开始为-1。列表内部支持字符，数字，字符串，甚至包含列表
2. +为连接操作，*为输出n次

t=['a','b','c']
t1=[:1]
# t1=['a','b']
t2=['a',20,2.3,'name']

4. python元组

1. 元组用()标识，内部元素用逗号分开，元组不能二次赋值，相当于只读列表

tuple1=('a',20,'name')
tuple1[1]=3300 #!!错误，不允许改变元组的值

5. python字典

1. 是除列表外，最灵活的类型，字典可以通过键来存取。字典用{}来表示，由key和value组成

dict={}
dict['one']='I\'m one'
dict[2]='Two'
dict1={'name':'ruun','code':666,'dept':'sales'}
print(dict[2])# 'Two'

6. 数据类型转换

1. 举例，其他类似

long(x)#x转换为长整数
str(x)#x转换为字符串

三、运算符

1.

• %:返回除法的余数 3%2 -> 1
• **：返回x的y次幂 10**2 -> 100
• ‘//’：返回商的整数部分 9//2 ->4

2.

• and,or,not 与，或，非

3. 判断是否在指定序列

• in
• not in

4. 身份运算符

• is #判断两个标识符是否引用自一个对象
• is not

a = 20
b = a
 
if ( a is b ):
   print "1 - a 和 b 有相同的标识"
else:
   print "1 - a 和 b 没有相同的标识"
 
if ( a is not b ):
   print "2 - a 和 b 没有相同的标识"
else:
   print "2 - a 和 b 有相同的标识"
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print "3 - a 和 b 有相同的标识"
else:
   print "3 - a 和 b 没有相同的标识"
 
if ( a is not b ):
   print "4 - a 和 b 没有相同的标识"
else:
   print "4 - a 和 b 有相同的标识"
#1 - a 和 b 有相同的标识
#2 - a 和 b 有相同的标识
#3 - a 和 b 没有相同的标识
#4 - a 和 b 没有相同的标识

四、

1. python没有switch语句，判断多条需要elif;判断多个条件，可以使用or

if num>0 and num <10:
    print('1')
elif num==0:
    print('0')

五、循环语句

1. while

    while (c<5):
        pass
    else:
        pass

2. for

a=['a','b','c']
for i in a:
    print(i)# 'a' 'b' 'c'
for i in range(len(a))
    print(a[i])# 'a' 'b' 'c'

六、

1. break,continue 语句与c++中作用相同，用于跳出循环
2. pass语句为空语句，保持程序完整

七、字符串

1. 字符串支持 in, not in 访问
2. print输出时，格式化字符串或者数字
3. 使用三引号，可实现所见即所得，不用再在内容内部使用转义字符

print ('I am %s and age is %d'%('Myy',18))
a='''I / % * '''

• %s-字符串
• %d-整数
• %c-字符
• %f-浮点数，可以指定小数点后精度

八 列表

• 利用append更新列表

• del删除列表某元素del list1[2]

• 支持in,not in操作

• 支持len()操作

• list1[-1],表示倒数第一个元素

• cmp(l1,l2)比较

• len(l1)

• max(l1)最大

• min(l1)

• list(seq)元组转为列表

• list.append

• list.count(obj)统计某个元素在list中出现次数

• list.extend(seq)一次追加另一个序列的多个值

• list.index(obj)找到该值并返回其索引

• list.insert(index,obj)插入

• list.pop[index=2])移除一个元素，默认是最后一个

• list.remove(obj)移除某个值的第一个匹配项

• list.reverse()反向表中元素

九、元组

• 元组与列表类似，不同之处在于元组不可修改，元组使用()，而列表用[]
• 元组中只包含一个元素时，需要在元素后面添加逗号。tuple=(50,)
• 可以通过索引访问元组值，可以进行截取，组合，但是不能修改其中的值
• 元组的某一个值不可以删除，但是允许del语句删除整个元组

t1=('a',3,'aaa')
t2=(4,)
t3=t1[2] #'aaa'
t4=t1+t2 # 'a',a,'aaa',4
del t4
print(t4) #报错！！

• 元组的运算符:支持in 遍历；

len((1,2,3)) # 3
t1=(1,)+(3,4) # (1,3,4)
t2=('A')*4 #('A','A','A','A')
for x in t2: print(x)

• 元素截取

L=('spam','Spam','SPAM')
L[2] #'SPAM'
L[-2] #'Spam'
L[1:] #'Spam','SPAM'

• 元组内置函数

• cmp(t1,t2) #比较
• len(tuple)
• max(tuple) 返回最大值
• min(tuple)
• tuple(seq) 将列表转为元组

十、字典

• 字典值的访问，直接通过索引key

dict={'name':'Zara','Age':7,'Class':'First'}
print(dict['name'])

• 字典里的内容可以通过key索引修改
• 支持删除某一元素、清空字典、删除整个字典

dict={'Name':'nancy','Age':4,'Class':'First'}
del dict['Name'] #删除某一条目
dict.clear() #清空字典
del dict #删除字典

• 字典内置函数

• cmp(d1,d2)
• len(d1)
• str(d1) # 输出字典可打印的字符串表示
• type(variable) #返回输入的变量类型
• dict.copy()#返回一个字典的浅复制
• dict.has_key(key)#如果键在字典里返回true,否则返回false
• dict.items() #以列表返回可遍历的(键，值)元组数组
• dict.update(d2)# 将d2的值更新到dict中
• dict.values() #以列表返回一个字典所有的值
• dict.keys() #以列表返回一个字典所有的键
• pop(key[,defalut]) 删除字典给定键key所对应的值，返回被删除的值
• popitem() 返回并删除字典最后一对键合值

十一、时间和日期

• 这里只说操作，具体实现用到再看该链接
• 获取当前时间
• 获取格式化好的时间
• 自定义格式化时间
• 获取某月日历

import time 
t=time.locatime(time.time())
print(t)
# time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)
....

十二、

1. python没有值传递或者引用传递的定义，但是可分 可变对象和不可变对象。python的列表和字典就是可变对象，在函数内部修改后，函数外部也会随着修改，其他诸如字符串，数字等则不可变

def f1(a):
    a=110
def f2(list1):
    list1.append([1,2,3])
b=0
list2=['a',1]
print(f1(b))# 0
print(f2(list2))#['a',1,1,2,3]

2.关键字参数，可以不按照顺序来传入参数,但要保持关键字相同

def f1(name,age):
print('name: ',name)
print('age: ',age)

f1(age=19,name='M')
# name: M
# age: 19

3.默认值参数，没有输入则打印默认值

def f1(age=30,name):
print('name:',name)
print('age:',age)

f1(name='miki')
# 'name:' miki
# 'age:' 30
f1(age=50,name='Zara')
# 'name:' Zara
# 'age:' 50

4.不定长列表或字符，数字等；不定长字典*args,**kwarg

def f1(name,*list):
    print(name)
    for i in list:
        print(i)
a=['a','b','c']
f1(name='Zara',a)
f1(name='Amili',1,2)

#--------------
def f1(**kwarg):print(kwarg)
f1(x=1,y=3,name='A')
# {'x':1,'y':3,'name':'A'}

5.lambda表达式

• 基本语法：lambda[arg1,agr2,…]:expression

sum=lambda arg1,arg2:arg1+agr2
print(sum(10,20))#30

6. 全局变量和局部变量

• 注意定义的全局变量在函数内部变为，局部变量

total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2 # total在这里是局部变量.
   print "函数内是局部变量 : ", total
   return total
 
#调用sum函数
sum( 10, 20 )
print "函数外是全局变量 : ", total

十三、

• import math后，调用其中的函数时需要match.sum(1,2)，加前缀
• ‘from A import B’，使用同上B(a,a)or B.fun()
• from A import*， 一次将所有A中内容引入

十四、

1. 读取键盘输入raw_input()、input()

两者区别就是input支持输入表达式进行计算

2. 文件的读写具体操作，用到时再参考该链接

str=raw_input("Input your words:")
print(str)
# Input your words: 111
# 111
str=('Input')
print(str)
# Input [x*4 for i in range(2)]
# [0,4]

十五、File操作

1. open(file,mode=‘r’),必须搭配close();mode为打开模式

mode 参数有

• x: 写模式，新建一个文件，如果该文件已经存在，则报错
• +：打开文件，可读可写
• r：只读形式，文件中指针放在文件开头
• r+：读写文件，指针在文件开头
• w：只写，如果文件已存在，则打开，并从头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件
• w+：读写，如果文件已存在，则打开，并从头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件
• a：追加文件，指针在文件尾。文件不存在则创建
• a+：追加，可读可写，文件指针会在文件结尾
  *…以及一些二进制形式处理的模式

2. file常用函数

• f.flush() 刷新文件内部缓冲
• f.close() 关闭文件
• f.next() 返回文件下一行
• f.readline() 读取整行，包括’\n’
• f.readlines() 读取所有行，并返回列表
• f.tell() 返回文件当前位置
• f.writelines(sequences) 向文件写入一个序列字符串列表，需要自己手动加入每行的换行符

十六 python常用内置函数

• abs() 绝对值
• divmod(a,d) 输出除法结果的商和余数
• enumerate() 将一个可遍历的数据对象，如列表，元组，组合为一个索引序列，同时给出数据和数据下标

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three

• math.pow() 求幂

import math
print(math.pow(3,0))# 1
print(math.pow(3,2))# 9

• map(fun,iterable)用法1，根据提供的函数对指定序列做映射
• map用法2，对某数据里的字符串进行字典式映射

# 1.
def f1(a):
    a*4
list2=map(f1,[1,2,3,4])
list3=map(lambda x:x*4,[1,2,3,4])
list4=map(lambda x,y:x*y,[1,2,3,4],[2,2,2,3])
# list2=[4,8,12,16]
# list3=[4,8,12,16]
# list4=[2,4,6,12]
# 2. 
MAP_SEX={'male':1,'female':0}
#     Sex
# 0   male 
# 1  female
data.map(MAX_SEX)
#     Sex
# 0    1 
# 1    0

• eval()执行一个字符串表达式，并返回表达式的值

x=7
eval('x*3')
>>21

• zip 将可迭代的对象作为参数，将对象中的元素打包为一个个元组，返回元组组成的列表

a=[1,2,2]
b=[4,5,6]
z=zip(a,b)
#c=[(1,4),(2,5),(2,6)]

• set创建一个无序不重复元素集，可删除重复数据，还可进行交集，差集，并集操作等
• id() 返回对象的内存地址
• 'sorted()'对列表内容进行排序，可以定义比较的规则

a=[3,4,1]
L=[('a',1),('c'.3),('e',0),('d',9)]
sorted(L,lambda x:x[1])#按照列表里的元素的第二个内容排序
#L=[('e',0),('a',1),('c'.3),('d',9)]