python从入门到..........

1、indentationError:是缩进错误。

2、

改成：

# -*- coding: cp936 -*-
import const
const.value=5;
print const.value;
print'我是一个字符串'

结果为：

解释：

# -*- coding: cp936 -*-这个注解是什么意思

这个用来声明你 .py 文件的编码，因为 Python 解释运行，所以也就表现为你程序的编码。
对于中文来说，常见的就是 utf-8 和 cp936，一般建议使用 utf-8。

2.1.3变量

标识符名字区分大小写。

Python的变量不需要声明，可以直接使用赋值运算符对其进行赋值操作，根据其所赋的值来决定其数据类型。

变量赋值实际就是将该变量的地址指向赋值给它的常量或变量的地址。

实验如下：

# -*- coding: cp936 -*-
print('Thank you')
print('hello')
a="这是一个变量"
b=a
print (b)
print ("\n")
a="这是另一个变量"
print (b)

#输出变量地址的示例程序
str1="这是一个变量"
print ("变量str1的值是："+str1)
print ("变量str1的地址是:%d"%(id(str1)))
str2 =str1
print ("变量str2的值是："+str2)
print ("变量str2的地址是：%d"%(id(str2)))
str1="这是另一个变量"
print ("变量str1的值是："+str1)
print ("变量str1的地址是：%d"%(id(str1)))
print ("变量str2的值是:"+str2)
print ("变量str2的地址是：%d"%(id(str2)))

实验结果为：

2.2数据类型

输出格式，

print ("languagelist列表的长度为：%d"    %(len(languagelist)))

注意，其与C的区别，C是print("格式字符+普通字符"，变量名）

2.2.2列表类型

练习：

# -*- coding: cp936 -*-
languagelist=['C++','C#','java','python']
print (languagelist)
print (languagelist[0])
print (languagelist[3])
print ("languagelist列表的长度为：%d"%(len(languagelist)))

languagelist.append('javascript')
print (languagelist)

languagelist.insert(0,'insert')
print (languagelist)

languagelist_other=['huanhuan','chenda']
languagelist.extend(languagelist_other)
print (languagelist)

languagelist_other=['javascript','C++']
languagelist.extend(languagelist_other)
print (languagelist)

languagelist.append('huanhuan')
print (languagelist)

languagelist1=['javascript','java']
languagelist2=['C++','C#','java']
languagelist3=languagelist1+languagelist2
print(languagelist3)

del languagelist3[0]
print (languagelist3)

languagelist=['C++','C#','Java','Python']
print(languagelist.index('Java'))
print(languagelist.index('Python'))

#利用for语句和range()函数遍历列表
for i in range(len(languagelist)):
    print(languagelist[i])
for index,value in enumerate(languagelist):
    print("第%d个元素值是[%s]"%(index,value));
#对列表排序
languagelist3.sort()
print(languagelist3)
languagelist3.reverse()
print(languagelist3)

list1=range(10)
list2=range(11,20)
#打印list1
for index ,value in enumerate(list1):
    print("list1的第%d个元素值是[%s]"%(index,value));
#打印list2
for index, value in enumerate(list2):
    print("list2的第%d个元素值是[%s]"%(index,value));
    
#定义二维列表
list2=[["CPU","Memory"],["Harddisk","sound card"]]
for i in range(len(list2)):
    print(list2[i])
    
for i in range(len(list2)):
    list1=list2[i]
    for j in range(len(list1)):
        print(list1[j])

for i in range(len(list2)):
    for j in range(len(list2[i])):
        print (list2[i][j])

运行结果为：

2.2.3元组

练习：

# -*- coding: cp936 -*-
#元组练习
#访问元组元素
t=(1,2,3,4)
print(t[0])
print(t[3])

#获取元组长度
print("t元组的长度为：%d"%len(t))

#可以使用for语句和range（）函数遍历列表索引，然后通过索引依次访问每个元组元素
#方法一：
t=('C++','C#','Java','python')
for i in range(len(t)):
    print (t[i])

#方法二：
for index,value in enumerate(t):
    print("第%d个元素值是[%s]"%(index,value))


#排序，由于元组的内容不能改变，所以元组没有sort、reverse函数，可以将元组转换为列表，然后再对列表进行排序，最后将排序后的列表赋值给元组
l=list(t)
l.sort();
t=tuple(l)
print(t)
 

运行结果为：

2.2.4字典和集合

# -*- coding: cp936 -*-
#字典练习
d={'name':"huanhuan",'sex':'female','age':'24','score':'90'}
print(d)
print(len(d))
print(d['name'])
print(d['sex'])
print(d['age'])
print(d['score'])

d['score']='100'
print(d)

d['school']='sdu'
print(d)

#将e里面的值合并到d中
e={'address':'hebei'}
d.update(e)
print(d)

#删除字典元素
d.pop('score')
print(d)

#判断字典是否存在元素
if 'name1' in d:
    print(d['name1'])
else:
    print('不包含键位name1的元素')
    
if 'name' in d:
    print(d['name'])
else:
    print('不包含键位name1的元素')

#遍历字典元素
#遍历字典的键
for key in d.keys():
    print('键'+key+ '的值：'+d[key]);
#遍历字典的值：
for value in d.values():
    print(value);

d.clear()
print(d)

#字典的嵌套
d={'name':{'first':'Johney','last':'Lee'},'age':40}
print(d['name']['first'])
#创建可变集合
s=set('python')
print(type(s))
print(s)

#创建不可变集合
fs=frozenset('python')
print(type(fs))
print(fs)

#打印集合的长度
s=set('python')
print(len(s))

#遍历集合元素
for e in s:
    print(e)
#添加一个集合元素的例子：
s.add('0')
print(s)
#添加多个集合元素的例子
s=set([1,2,3])
s.update([4,5,6])
print(s)
#删除集合元素的例子
s.remove(1)
print(s)
s.clear()
print(s)


#判断集合是否存在元素
s=set([1,2,3])
if 2 in s:
    print('exist')
else:
    print('not exist')



#集合的并集
s1=set([1,2])
s2=set([3,4])
s=s1|s2
print(s)
        
s1=set([7,8])
s2=set([9,0])
s=s1.union(s2)
print(s)
#集合的交集
s1=set([1,2,3])
s2=set([3,4])
s=s1&s2
print(s)

d1=s1.intersection(s2)
print(d1)

#集合的差集
s=s1-s2
print(s)

#集合的对称差分
s=s1^s2
print(s)

s=s1.symmetric_difference(s2)
print(s)

实验结果：

2.3.2运算符的使用

# -*- coding: cp936 -*-
#整除运算，即返回商的整数部分
a=9
b=2
c=a//b
print(c)

#幂运算
a=1
b=3
c=a**b
print(a)

c=2**3
print(c)

#赋值运算符的使用实例
x=3
x+=3
print(x)
x-=3
print(x)
x*=3
print(x)
x/=3
print(x)


#逻辑运算符的使用
x=True
y=False
print("x and y=",x and y)
print("x or y=",x or y)
print("not x=",not x)
print("not y=",not y)

#字符串运算符
b="hello"
a=b+"world"
print(a)
print(a*2)
print(r"hello\nworld")

#表达式的使用
b=3
c=2
a=b+c
print(a)
a=b-c
print(a)
a=b*c
print(a)
a=b/c
print(a)
a=b%c
print(a)
a+=1
print(a)
b=a**2
print(b)

实验结果为：

2.4Python对象

2.4.2定义类和使用类

# -*- coding: cp936 -*-
class Person:
    def SayHello(self):
        print("Hello!");
p=Person()
p.SayHello()

class MyString:
    str="MyString";
    def output(self):
        print(self.str);
s=MyString()
s.output()


class UserInfo:
    def __init__(self,name,pwd):
        self.username=name;
        self._pwd=pwd;
    def output(self):
        print("用户："+self.username+"\n密码:"+self._pwd);
u=UserInfo("admin","123456")
u.output()


class MyString:
    def __init__(self):
        self.str="MyString";
    def output(self):
        print(self.str);
s=MyString();
s.output();


class MyString:
    def __init__(self):#构造函数
        self.str="MyString";
    def __del__(self):#析构函数
        print("byebye~");
    def output(self):
        print(self.str);
s=MyString();
s.output();
del s #删除对象

实验结果：

2.4.3静态方法

# -*- coding: cp936 -*-
class Users(object):
    online_count=0;
    def __init__(self):#构造函数，创建对象时Users.online_count加1
        Users.online_count+=1;
    def __del__(self):#析构函数，释放对象时Users.online_count减1
        Users.online_count-=1;
a=Users();
a.online_count+=1;
print(Users.online_count);#此时输出是1
print(a.online_count);#注意此时输出是2


class MyClass:
    var1='String1'
    @staticmethod#静态方法
    def staticmd():
         print("我是静态方法")
MyClass.staticmd();
c=MyClass();
c.staticmd();

实验结果：

2.4.4类方法

2.4.6类的继承及多态

注意：哪些是属于类；哪些不属于类；决定编写代码时，其对齐方式的不同。若没弄清楚会出现如下错误。

即，当now与类成员函数对齐时，会出现某变量名没有定义。

上面图片相当于，now和三个对象均属于类的成员函数里面的，对齐方式的不同，会导致出现的问题不同；所以千万要注意编程格式。

类继承实验代码如下：

# -*- coding: cp936 -*-
import time
class Users:
    username=""
    def __init__(self,uname):
        self.username=uname;
        print('(构造函数：'+self.username+')')#初始化用户名
    def dispUserName(self):#显示用户名
        print(self.username);
class UserLogin(Users):
    def __init__(self,uname,lastLoginTime):
        Users.__init__(self,uname);
        self.lastLoginTime=lastLoginTime
    def dispLoginTime(self):
        print("登录时间为："+self.lastLoginTime);
#获取当前时间
now=time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()));
#声明3个对象
myUser_1=UserLogin('admin',now);
myUser_2=UserLogin('lee',now);
myUser_3=UserLogin('zhang',now);
#分别调用父类和子类的函数
myUser_1.dispUserName();
myUser_1.dispLoginTime();
myUser_2.dispUserName();
myUser_2.dispLoginTime();
myUser_3.dispUserName();
myUser_3.dispLoginTime();

实验结果为：

2.4.6抽象类的定义

注意：定义抽象类之前，必须写上from abc import ABCMeta, abstractmethod才可以以写抽象类的定义。因为定义抽象类的时候，需要从类库abc导入ABCMeta类和abstractmethod类

代码的实现：

# -*- coding: cp936 -*-
from abc import ABCMeta, abstractmethod

class Shape(object):
    __metaclass__=ABCMeta
    def __init__(self):
        self.color='black'#默认使用黑色
    @abstractmethod
    def draw(self):pass

    
#可以看到不同子类，抽象方法draw()有不同的实现，这就是多态
class circle(Shape):
    def __init__(self,x,y,r):#定义圆心坐标和半径
        self.x=x;
        self.y=y;
        self.r=r;
    def draw(self):
        print("Draw Circle:(%d,%d,%d)"%(self.x,self.y,self.r));
class line(Shape):
    def __init__(self,x1,y1,x2,y2):#定义起止坐标值
        self.x1=x1;
        self.y1=y1;
        self.x2=x2;
        self.y2=y2;
    def draw(self):
        print("Draw Line:(%d,%d,%d,%d)"%(self.x1,self.y1,self.x2,self.y2));
        
c=circle(10,10,5);
c.draw();
l=line(10,10,20,20);
l.draw();

#因为抽象类的子类都是实现了抽象类中定义的抽象方法，所以可以把同一抽象类的各种子类对象定义成一个序列的元素，然后遍历列表，调用抽象方法。
list=[];
list.append(c);
list.append(l);
for i in range(len(list)):
    list[i].draw();

实验结果为：

如果，没有添加from abc import ABCMeta, abstractmethod的时候，会出现如下问题：

2.4.7对象的序列化

将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

序列化的过程称为pickle（腌制），可以将对象pickle成字符串，磁盘上的文件或者任何类似于文件的对象，也可以将这些字符串，文件或类似于文件的对象unpickle成原来的对象。

练习：

注意当，import某文件时，该程序的文件名称一定不要写成import  库文件的名称，否则会出现如下问题：

即，因为你把自己的源文件起名为pickle.py，“import pickle.py”实际上import的是你自己的代码。

将对象序列化成字符串：

实验代码如下：

# -*- coding: cp936 -*-
import pickle
lista=['C++','C#','Java','Python'];
listb=pickle.dumps(lista);
print(listb);

结果为：

反序列化为：使用pickle.loads()方法可以将使用pickle.dumps()方法得到的字符串反序列化成原来的对象。

代码如下：

# -*- coding: cp936 -*-
import pickle
lista=['C++','C#','Java','Python'];
listb=pickle.dumps(lista);
listc=pickle.loads(listb);
print(listc);

结果为：

将对象序列化到文件和从文件中反序列化：

代码如下：

import pickle
list1=['C++','C#','Java','Python'];
output=open('data.txt','wb');
pickle.dump(list1,output);
output.close();

import pickle
f=open('data.txt','rb');
list=pickle.load(f);
print(list);
f.close();

结构为：

两个import，分开执行时：

第一个import执行完后到文件中的内容为：

第三章常用Python语句

3.2.1条件分支语句：

代码如下：

# -*- coding: cp936 -*-
import datetime
str="今天是";
d=datetime.datetime.now();#返回的是本地时区的当前时间2017-04-25
print(d.weekday());
if d.weekday()==0:
    str +="星期一";
elif d.weekday()==1:
    str +="星期二";
elif d.weekday()==2:
    str +="星期三";
elif d.weekday()==3:
    str +="星期四";
elif d.weekday()==4:
    str +="星期五";
elif d.weekday()==5:
    str +="星期六";
else:
    str +="星期日";
print(str);
    

结果为：

3.2.2循环语句：

while和for语句：

i=1;
sum=0;
while i<11:
    sum +=i;
    i +=1;
print(sum);

i=1;
sum=0;
for i in range(1,11):#当i=11时for退出
    print(i);
    sum +=i;
print(sum);
#continue是进入下一次循环
i=1;
sum=0;
for i in range(1,101):
    if i%2==1:
        continue;
    sum+=i;
print(sum);
#break跳出循环体
i=1;
sum=0;
while True:
    if i==11:
        break;
    sum+=i;
    i+=1;
print(sum);

结果为：

补充知识：
 Python 有办法将任意值转为字符串：将它传入repr() 或str() 函数。
    函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式
（如果没有等价的语法，则会发生SyntaxError 异常） 某对象没有适于人阅读的解释形式的话， str() 会返回与repr()
   等同的值。很多类型，诸如数值或链表、字典这样的结构，针对各函数都有着统一的解读方式。
   字符串和浮点数，有着独特的解读方式。


>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1.0/7.0)
'0.142857142857'
>>> repr(1.0/7.0)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print s
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print hellos
'hello, world\n'
>>> # The argument to repr() may be any Python object:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

4.7迭代器和生成器

#闭包有什么好处,为什么不直接使用嵌套函数的定义呐.
def func_lib():
    def add(x,y):
        return x+y;
    return add;
fadd=func_lib();
print(fadd(1,2));

#递归
def fact(n):
    if n==1:
        return 1;
    return n*fact(n-1);
print(fact(5));

#迭代器的使用
list=['C++','C#','Java','Python']
it=iter(list);
print(next(it));#起初，it在-1处，用了next后，到下标为0的地方。
print(next(it));
print(next(it));
print(next(it));

list=['C++','C#','Java','Python'];
for index ,val in enumerate(list):
    print("第%d个元素是%s"%(index+1,val));

运行结果为：