频道栏目
首页 > 程序开发 > Web开发 > Python > 正文
python学习备忘录--2
2012-02-10 09:22:55           
收藏   我要投稿

上一篇:/kf/201202/118740.html

1,前言
   前面的备忘录提到了python的基本教程,基本上本文例子都是沈洁元的简明教程里面的内容,这两篇都是读书笔记,算不上派生,主要也是自己备忘用的,译者见谅。
   基本上本文的解释是自己的理解,没有采用书本中的讲解,觉得自己解释可能更容易记住。

   上篇备忘主要是面向过程来讲述的,其实python是凡事都是对象的一种解释语言。包括类型int啊等等都是对象,与C/C++显然不同,在这两个语言中,类型是作为原子来定义的,主要是用来分配内存字节而用,没有所谓方法,当然这点在VC中做了一定改变,比如对字符串的处理显然是比C要方便一些。

    python和perl,还是Python容易懂些,效率差了

2,面向对象的python
   2.1,类创建一个新类型,而对象这个类的 实例。
   2.2,对象可以使用普通的 属于 对象的变量存储数据。属于一个对象或类的变量被称为域。对象也可以使用 属于 类的函数来具有功能。这样的函数被称为类的方法。域和方法可以合称为类的属性。
   2.3,域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。类使用class关键字创建。类的域和方法被列在一个缩进块中。

3,类

   3.1,self参数

             类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,但是在调用这个方法的时候你不为这个参数赋值,Python会提供这个值。这个特别的变量指对象本身,按照惯例它的名称是self。

            self 本身不需要赋值,由python自动完成功能,如果你的实例调用一个方法,例如:假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候,这会由Python自动转为MyClass.method(MyObject, arg1, arg2)
  3.2,创建一个类
    我们看下面这个例子:
[python]
#!/usr/bin/python  
 # Filename: simplestclass.py  
 
 class Person: 
         pass # An empty block  
 
 p = Person() 
 print p 
      #!/usr/bin/python
       # Filename: simplestclass.py

       class Person:
               pass # An empty block

       p = Person()
       print p      如果你去掉pass前面的缩进,会提示错误,期待一个缩进,一定要记住python是由缩进来区别语句块的,习惯C的人要留心。
      结果打印的是这个实例的内存地址。

       再者要注意的是:python中表示空语句必须写个pass,而不是像C中括号一括完事,因为python是用缩进来区别语句块的。所以你不缩进,解释器就不懂了。
  3.3,对象的方法
      对象方法与函数类似,只不过多了一个额外的self变量。
      我们来看一个方法:
[python]
  #!/usr/bin/python  
  # Filename: method.py  
 class Person: 
         def sayHi(self): 
            print 'Hello, how are you?' 
p = Person() 
p.sayHi() 
      #!/usr/bin/python
      # Filename: method.py
     class Person:
             def sayHi(self):
                print 'Hello, how are you?'
    p = Person()
    p.sayHi()    # This short example can also be written as Person().sayHi()
   要注意sayHi方法没有任何参数。我个人觉得之所以需要一个self做方法默认参数可能是由于python是门解释型语言,便于解释器解释。刚学这只是种感觉,不对之处请指正。

   3.4,一些特殊方法
        这里面其实涉及了一些并不陌生的概念
   3.4.1 __init__方法
        这个方法其实就是构造函数啊,大家懂了吧,而且上篇没有提到,python是变量不需要事前声明的,说实话看到下面这个例子,还是多少有点不适应
[python]
#!/usr/bin/python  
           # Filename: class_init.py  
           class Person: 
               def __init__(self, name): 
                      self.name = name 
          def sayHi(self): 
          print 'Hello, my name is', self.name 
          p = Person('Swaroop') 
          p.sayHi() 
          # This short example can also be written as Person('Swaroop').sayHi() 
 #!/usr/bin/python
            # Filename: class_init.py
            class Person:
                def __init__(self, name):
                       self.name = name
           def sayHi(self):
           print 'Hello, my name is', self.name
           p = Person('Swaroop')
           p.sayHi()
           # This short example can also be written as Person('Swaroop').sayHi()这里面的属性域没有声明啊,也不说什么类型,在语法严格C++中显的是相当糟糕。

创建一个类的新实例的时候,把参数包括在圆括号内跟在类名后面,从而传递给__init__方法。

这个你要是习惯C++/Java之类的强制类型申明语言,看到这个self.name很不适应。还是把self参数当成系统需要的参数就好了。


下面这个例子可以解释一下为什么实例的属性域可以不用声明,对于python而已,创建实例适合,调用的__init__方法
[python]
#!/usr/bin/python  
# Filename: objvar.py  
 
class Person: 
    '''''Represents a person.''' 
    population = 0 
 
    def __init__(self, name): 
        '''''Initializes the person's data.''' 
        self.name = name 
        print '(Initializing %s)' % self.name 
 
        # When this person is created, he/she  
        # adds to the population  
        Person.population += 1 
 
    def __del__(self): 
        '''''I am dying.''' 
        print '%s says bye.' % self.name 
 
        Person.population -= 1 
 
        if Person.population == 0: 
            print 'I am the last one.' 
        else: 
            print 'There are still %d people left.' % Person.population 
 
    def sayHi(self): 
        '''''Greeting by the person.
 
        Really, that's all it does.''' 
        print 'Hi, my name is %s.' % self.name 
 
    def howMany(self): 
        '''''Prints the current population.''' 
        if Person.population == 1: 
            print 'I am the only person here.' 
        else: 
            print 'We have %d persons here.' % Person.population 
 
swaroop = Person('Swaroop') 
swaroop.sayHi() 
swaroop.howMany() 
 
kalam = Person('Abdul Kalam') 
kalam.sayHi() 
kalam.howMany() 
 
swaroop.sayHi() 
swaroop.howMany() 
#!/usr/bin/python
# Filename: objvar.py

class Person:
    '''Represents a person.'''
    population = 0

    def __init__(self, name):
        '''Initializes the person's data.'''
        self.name = name
        print '(Initializing %s)' % self.name

        # When this person is created, he/she
        # adds to the population
        Person.population += 1

    def __del__(self):
        '''I am dying.'''
        print '%s says bye.' % self.name

        Person.population -= 1

        if Person.population == 0:
            print 'I am the last one.'
        else:
            print 'There are still %d people left.' % Person.population

    def sayHi(self):
        '''Greeting by the person.

        Really, that's all it does.'''
        print 'Hi, my name is %s.' % self.name

    def howMany(self):
        '''Prints the current population.'''
        if Person.population == 1:
            print 'I am the only person here.'
        else:
            print 'We have %d persons here.' % Person.population

swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()

kalam = Person('Abdul Kalam')
kalam.sayHi()
kalam.howMany()

swaroop.sayHi()
swaroop.howMany()     观察可以发现__init__方法用一个名字来初始化Person实例。在这个方法中,我们让population增加1,这是因为我们增加了一个人。同样可以发现,self.name的值根据每个对象指定,这表明了它作为对象的变量的本质。

    运行上述脚本,提示Exception AttributeError: "'NoneType' object has no attribute 'population'" in <bound method Person.__del__ of <__main__.Person instance at 0xb7746eec>> ignored;

    原因是对象销毁时,全局变量的问题。

    我另写了一篇备注,记录学习一下错误和心得,这里先列出遇到的问题。记住一点,不要使用__def__方法。

 


     你只能使用self变量来参考同一个对象的变量和方法。这被称为 属性参考 。
     在这个程序中,我们还看到docstring对于类和方法同样有用。我们可以在运行时使用Person.__doc__和Person.sayHi.__doc__来分别访问类与方法的文档字符串。
      就如同__init__方法一样,还有一个特殊的方法__del__,它在对象消逝的时候被调用。对象消逝即对象不再被使用,它所占用的内存将返回给系统作它用。在这个方法里面,我们只是简单地把Person.population减1。

       当对象不再被使用时,__del__方法运行,但是很难保证这个方法究竟在 什么时候 运行。

我们正常运行一次:

我们在这个脚本里面添加:
print Person.__doc__
print Person.sayHi.__doc__
我们看下运行结果:
b2c@b2c-server:~$ python demo.py
(Initializing Swaroop)
Hi, my name is Swaroop.
I am the only person here.
(Initializing Abdul Kalam)
Hi, my name is Abdul Kalam.
We have 2 persons here.
Hi, my name is Swaroop.
We have 2 persons here.
Represents a person.
Greeting by the person.


        Really, that's all it does.
Abdul Kalam says bye.
There are still 1 people left.
Swaroop says bye.
I am the last one.

有没有发现什么?可以看到我们的文档字符串或者说是说明文字不是最后显示,而脚本中其实是最后两条语句,这个是因为__del__方法,脚本执行最后,实例被销毁,所以方法执行,出现提示。明白了没。
所以这个__del__是析构函数,类似概念。

这里面多说一句,python其实类中成员默认都是公开的,私有成员是后来语言加入的特性,以双下划线__作为标志。如一个变量__var为私有变量,包括子类在内的外部调用都是无效的。python 是采用从新命名这个私有变量名字而避开外部调用的,非常简单,所以会提示你找不到。

缩进要注意逻辑对齐!

 


  3.5,继承

     面向对象的核心概念之一,为了代码重用和逻辑相关性而定义。有过OOP基础的都应该不陌生。
子类型实例可以自然的被当作父类型使用,支持多重继承。
[python]
     #!/usr/bin/python  
# Filename: inherit.py  
 
class SchoolMember: 
    '''''Represents any school member.''' 
    def __init__(self, name, age): 
        self.name = name 
        self.age = age 
        print '(Initialized SchoolMember: %s)' % self.name 
 
    def tell(self): 
        '''''Tell my details.''' 
        print 'Name:"%s" Age:"%s"' % (self.name, self.age), 
 
class Teacher(SchoolMember): 
    '''''Represents a teacher.''' 
    def __init__(self, name, age, salary): 
        SchoolMember.__init__(self, name, age) 
        self.salary = salary 
        print '(Initialized Teacher: %s)' % self.name 
 
    def tell(self): 
        SchoolMember.tell(self) 
        print 'Salary: "%d"' % self.salary 
 
class Student(SchoolMember): 
    '''''Represents a student.''' 
    def __init__(self, name, age, marks): 
        SchoolMember.__init__(self, name, age) 
        self.marks = marks 
        print '(Initialized Student: %s)' % self.name 
 
    def tell(self): 
        SchoolMember.tell(self) 
       print 'Marks: "%d"' % self.marks 
 
t = Teacher('Mrs. Shrividya', 40, 30000) 
s = Student('Swaroop', 22, 75) 
 
print # prints a blank line  
members = [t, s] 
for member in members: 
    member.tell() # works for both Teachers and Students 
     #!/usr/bin/python
# Filename: inherit.py

class SchoolMember:
    '''Represents any school member.'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print '(Initialized SchoolMember: %s)' % self.name

    def tell(self):
        '''Tell my details.'''
        print 'Name:"%s" Age:"%s"' % (self.name, self.age),

class Teacher(SchoolMember):
    '''Represents a teacher.'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print '(Initialized Teacher: %s)' % self.name

    def tell(self):
        SchoolMember.tell(self)
        print 'Salary: "%d"' % self.salary

class Student(SchoolMember):
    '''Represents a student.'''
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print '(Initialized Student: %s)' % self.name

    def tell(self):
        SchoolMember.tell(self)
       print 'Marks: "%d"' % self.marks

t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 22, 75)

print # prints a blank line
members = [t, s]
for member in members:
    member.tell() # works for both Teachers and Students这个例子可以看出继承的基本含义。另外说一点,子类构造函数必须人工构造父类的构造函数,不能自动完成,这点与其他OOP语言有点区别。
    Python不会自动调用基本类的constructor,你得亲自专门调用它。

 


4,I/O

   4.1,文件

你可以通过创建一个file类的对象来打开一个文件。

这个IO操作还是比较方便,能直接调用file()

[python]
#!/usr/bin/python  
# Filename: using_file.py  
 
poem = '''''\
Programming is fun
When the work is done
if you wanna make your work also fun:
        use Perl!
''' 
f = file('poem.txt', 'w') # open for 'w'riting  
f.write(poem) # write text to file  
f.close() # close the file  
f = file('poem.txt') 
# if no mode is specified, 'r'ead mode is assumed by default  
while True: 
   line = f.readline() 
   if len(line) == 0: # Zero length indicates EOF  
       break 
   print line, 
   # Notice comma to avoid automatic newline added by Python  
f.close() # close the file  
#!/usr/bin/python
# Filename: using_file.py

poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
        use Perl!
'''
f = file('poem.txt', 'w') # open for 'w'riting
f.write(poem) # write text to file
f.close() # close the file
f = file('poem.txt')
# if no mode is specified, 'r'ead mode is assumed by default
while True:
   line = f.readline()
   if len(line) == 0: # Zero length indicates EOF
       break
   print line,
   # Notice comma to avoid automatic newline added by Python
f.close() # close the file 我们通过指明我们希望打开的文件和模式来创建一个file类的实例。模式可以为读模式('r')、写模式('w')或追加模式('a')。事实上还有多得多的模式可以使用,你可以使用help(file)来了解它们的详情。
如果没有指定模式,读将作为默认模式。

在一个循环中,我们使用readline方法读文件的每一行。这个方法返回包括行末换行符的一个完整行。所以,当一个 空的 字符串被返回的时候,即表示文件末已经到达了,于是我们停止循环。

这里面有个小疑问就是while语句的true是根据上下文来判断的么?我改成f也是可以的.

注意,因为从文件读到的内容已经以换行符结尾,所以我们在print语句上使用逗号来消除自动换行。最后,我们用close关闭这个文件。

 

4.2 存储器

Python提供一个标准的模块,称为pickle。使用它你可以在一个文件中储存任何Python对象,之后你又可以把它完整无缺地取出来。这被称为 持久地 储存对象。
还有另一个模块称为cPickle,它的功能和pickle模块完全相同,只不过它是用C语言编写的,因此要快得多(比pickle快1000倍)。C就是牛逼啊。哈哈
[python]
#!/usr/bin/python  
# Filename: pickling.py  
 
import cPickle as p 
#import pickle as p  
 
shoplistfile = 'shoplist.data' 
# the name of the file where we will store the object  
 
shoplist = ['apple', 'mango', 'carrot'] 
 
# Write to the file  
f = file(shoplistfile, 'w') 
p.dump(shoplist, f) # dump the object to a file  
f.close() 
 
del shoplist # remove the shoplist  
 
# Read back from the storage  
f = file(shoplistfile) 
storedlist = p.load(f) 
print storedlist 
#!/usr/bin/python
# Filename: pickling.py

import cPickle as p
#import pickle as p

shoplistfile = 'shoplist.data'
# the name of the file where we will store the object

shoplist = ['apple', 'mango', 'carrot']

# Write to the file
f = file(shoplistfile, 'w')
p.dump(shoplist, f) # dump the object to a file
f.close()

del shoplist # remove the shoplist

# Read back from the storage
f = file(shoplistfile)
storedlist = p.load(f)
print storedlist首先,请注意我们使用了import..as语法。这是一种便利方法,以便于我们可以使用更短的模块名称。在这个例子中,它还让我们能够通过简单地改变一行就切换到另一个模块(cPickle或者pickle)!在程序的其余部分的时候,我们简单地把这个模块称为p。

为了在文件里储存一个对象,首先以写模式打开一个file对象,然后调用储存器模块的dump函数,把对象储存到打开的文件中。这个过程称为 储存 。

接下来,我们使用pickle模块的load函数的返回来取回对象。这个过程称为 取储存 。
这个是涉及I/O操作用的

5,异常处理
    应该说高级语言里面都有异常处理的内容。
    我们程序出现问题的适合,解释器会告诉我们出错了,有些时候对用户显示这些显然是不友好的。所以,有点类似catch...throw,这里面有try...except。
[python]
#!/usr/bin/python  
# Filename: try_except.py  
 
import sys 
 
try: 
    s = raw_input('Enter something --> ') 
except EOFError: 
    print '\nWhy did you do an EOF on me?' 
    sys.exit() # exit the program  
except: 
    print '\nSome error/exception occurred.' 
    # here, we are not exiting the program  
print 'Done' 
#!/usr/bin/python
# Filename: try_except.py

import sys

try:
    s = raw_input('Enter something --> ')
except EOFError:
    print '\nWhy did you do an EOF on me?'
    sys.exit() # exit the program
except:
    print '\nSome error/exception occurred.'
    # here, we are not exiting the program
print 'Done'这个程序运行以后,按“Ctrl+C”或者“Ctrl+D”看看结果。。


5.2,自定义异常
    可以自己定义异常来显示。
     你可以使用raise语句 引发 异常。你还得指明错误/异常的名称和伴随异常 触发的 异常对象。你可以引发的错误或异常应该分别是一个Error或Exception类的直接或间接导出类。
    自己定义的异常类要是Exception类的子类。

    这里,我们创建了我们自己的异常类型,其实我们可以使用任何预定义的异常/错误。这个新的异常类型是ShortInputException类。它有两个域——length是给定输入的长度,atleast则是程序期望的最小长度。

在except从句中,我们提供了错误类和用来表示错误/异常对象的变量。这与函数调用中的形参和实参概念类似。在这个特别的except从句中,我们使用异常对象的length和atleast
[python]
#!/usr/bin/python  
# Filename: raising.py  
 
 
class ShortInputException(Exception): 
    '''''A user-defined exception class.''' 
    def __init__(self, length, atleast): 
        Exception.__init__(self) 
        self.length = length 
        self.atleast = atleast 
 
try: 
    s = raw_input('Enter something --> ') 
    if len(s) < 3: 
        raise ShortInputException(len(s), 3) 
    # Other work can continue as usual here  
except EOFError: 
    print '\nWhy did you do an EOF on me?' 
except ShortInputException, x: 
    print 'ShortInputException: The input was of length %d, \ 
          was expecting at least %d' % (x.length, x.atleast) 
else: 
    print 'No exception was raised.' 
#!/usr/bin/python
# Filename: raising.py


class ShortInputException(Exception):
    '''A user-defined exception class.'''
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

try:
    s = raw_input('Enter something --> ')
    if len(s) < 3:
        raise ShortInputException(len(s), 3)
    # Other work can continue as usual here
except EOFError:
    print '\nWhy did you do an EOF on me?'
except ShortInputException, x:
    print 'ShortInputException: The input was of length %d, \
          was expecting at least %d' % (x.length, x.atleast)
else:
    print 'No exception was raised.'    这里,我们创建了我们自己的异常类型,其实我们可以使用任何预定义的异常/错误。这个新的异常类型是ShortInputException类。它有两个域——length是给定输入的长度,atleast则是程序期望的最小长度。

   在except从句中,我们提供了错误类和用来表示错误/异常对象的变量。这与函数调用中的形参和实参概念类似。在这个特别的except从句中,我们使用异常对象的length和atleast域来为用户打印一个恰当的消息.


5.3,try..finally
     单词意思可知,finally是无论异常发生与否都要完成的动作。
[python]
 #!/usr/bin/python  
# Filename: finally.py  
 
import time 
 
try: 
    f = file('poem.txt') 
    while True: # our usual file-reading idiom  
        line = f.readline() 
        if len(line) == 0: 
            break 
        time.sleep(2) 
        print line, 
finally: 
    f.close() 
    print 'Cleaning up...closed the file' 
 #!/usr/bin/python
# Filename: finally.py

import time

try:
    f = file('poem.txt')
    while True: # our usual file-reading idiom
        line = f.readline()
        if len(line) == 0:
            break
        time.sleep(2)
        print line,
finally:
    f.close()
    print 'Cleaning up...closed the file'睡了2秒,是故意延长时间,好让你按“Ctrl+D”,按了你也发现,文件还是关闭了最后。

6,python标准库
 6.1,sys模块
     顾名思义,系统库。
[python]
 #!/usr/bin/python  
# Filename: cat.py  
 
import sys 
 
def readfile(filename): 
    '''''Print a file to the standard output.''' 
    f = file(filename) 
    while True: 
        line = f.readline() 
        if len(line) == 0: 
            break 
        print line, # notice comma  
    f.close() 
 
# Script starts from here  
if len(sys.argv) < 2: 
    print 'No action specified.' 
    sys.exit() 
 
if sys.argv[1].startswith('--'): 
    option = sys.argv[1][2:] 
    # fetch sys.argv[1] but without the first two characters  
    if option == 'version': 
        print 'Version 1.2' 
    elif option == 'help': 
        print '''''\
This program prints files to the standard output.
Any number of files can be specified.
Options include:
  --version : Prints the version number
  --help    : Display this help''' 
    else: 
        print 'Unknown option.' 
    sys.exit() 
else: 
    for filename in sys.argv[1:]: 
        readfile(filename) 
 #!/usr/bin/python
# Filename: cat.py

import sys

def readfile(filename):
    '''Print a file to the standard output.'''
    f = file(filename)
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print line, # notice comma
    f.close()

# Script starts from here
if len(sys.argv) < 2:
    print 'No action specified.'
    sys.exit()

if sys.argv[1].startswith('--'):
    option = sys.argv[1][2:]
    # fetch sys.argv[1] but without the first two characters
    if option == 'version':
        print 'Version 1.2'
    elif option == 'help':
        print '''\
This program prints files to the standard output.
Any number of files can be specified.
Options include:
  --version : Prints the version number
  --help    : Display this help'''
    else:
        print 'Unknown option.'
    sys.exit()
else:
    for filename in sys.argv[1:]:
        readfile(filename)这里面说明一下:argv自动将脚本文件名认为是argv[0],从0开始计数,与C语言一样,如果出现argv[1][2:]则是第二个参数,用户角度是第一个参数抛弃前两个字符,截取剩余字符的意思。
至于argv[1:]则应该是从用户角度的第一个参数依次到参数列表的最后。
readfile()函数输出文件内容,首先判断参数数量,少于2个显然是没有输入文件名称,给出提示反馈,如果参数是以--开头的则抛弃前两个字符,截取剩下字符通过流程匹配分别输出提示。最后,把参数列表中的文件一个个输出就是了

这里面有三个模块比较常用先记下:sys.stdin、sys.stdout和sys.stderr它们分别对应你的程序的标准输入、标准输出和标准错误流。

   6.2,OS模块
这个模块包含普遍的操作系统功能。如果你希望你的程序能够与平台无关的话,这个模块是尤为重要的。即它允许一个程序在编写后不需要任何改动,也不会发生任何问题,就可以在Linux和Windows下运行。一个例子就是使用os.sep可以取代操作系统特定的路径分割符。
        这个对于我那是相当重要了,毕竟现在用LINUX桌面的人简直是凤毛麟角啊。
        os模块里面有很多方法很有用,平时可以查看一下文档。
[python]
os.name字符串指示你正在使用的平台. 
os.getcwd()函数得到当前工作目录。 
os.linesep字符串给出当前平台使用的行终止符。 
os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。类似地,os.path.existe()函数用来检验给出的路径是否真地存在。 
os.name字符串指示你正在使用的平台.
os.getcwd()函数得到当前工作目录。
os.linesep字符串给出当前平台使用的行终止符。
os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。类似地,os.path.existe()函数用来检验给出的路径是否真地存在。基本上python基本东西都在这里么了,当然讲的也是皮毛,在以后真正开发中我会不断添加内容和学习备忘的。


摘自 DesignLab
 

点击复制链接 与好友分享!回本站首页
相关TAG标签 备忘录
上一篇:centos下升级python
下一篇:AttributeError: 'module' object has no attribute 的解决方法
相关文章
图文推荐
文章
推荐
点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站