python学习之路之基础篇（二）

函数定义和调用

def printme(str):
    # 打印任何传入的字符串
    print(str)
    return


printme('我要调用用户自定义函数！')   # 格式要求 空两行
printme('我要再次调用！')

参数传递

在python中，strings, tuples, 和numbers是不可更改的对象，而 list,dict 等则是可以修改的对象。
（1）不可变类型：变量赋值a=5后再赋值a=10，这里实际是新生成一个int值对象10，再让a指向它，而5被丢弃，不是改变a的值，相当于新生成了a。
（2）可变类型：变量赋值la=[1,2,3,4] 后再赋值la[2]=5则是将list la的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：
（1）不可变类型：类似c++的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
（2）可变类型：类似c++的引用传递，如 列表，字典。如fun（la），则是将la真正的传过去，修改后fun外部的la也会受影响

python中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

传不可变对象实例

def changeint(a):
    a = 10
    print(a)


b = 2  # 格式要求，在类或自定义功能之后空两行
changeint(b)
print(b)

输出结果：10,2
实例中有int对象2，b指向它，在传递给changeint函数时，按传值的方式复制了变量b，a和b都指向了同一个int对象2，在a=10时，则新生成了一个int对象10，让a指向它。

传可变对象实例

所有参数（自变量）在Python里都是按引用传递。如果在函数里修改了这个参数，那么在调用这个函数的函数里，原始的参数也被改变了。

def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print "函数内取值: ", mylist
   return
 
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print "函数外取值: ", mylist

输出结果：函数内取值：[10,20,30,[1,2,3,4]]
函数外取值：[10,20,30,[1,2,3,4]]

面向对象

class People:
    name = ''
    age = 0
    __weight = 0  #私有属性

    def __init__(self, n, a, w):  # 初始化函数
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print('%s说：我%d岁。' % (self.name, self.age))


p = People('lily', 18, 30)  # 实例化类
p.speak()


class Student(People):  # 单继承实例
    grade = ''

    def __init__(self, n, a, w, g):
        People.__init__(self, n, a, w)  # 调用父类的构造函数
        self.grade = g

    def speak(self):   #覆写父类的方法
        print('%s说：我%d岁了，我在读%s年级。' % (self.name, self.age, self.grade))


s = Student('Ken', 10, '', '五')  # 参数要传够
s.speak()


class Speaker():  # 另一个类
    name = ''
    topic = ''

    def __init__(self, n, t):
        self.name = n
        self.topic = t

    def speak(self):
        print('%s说：我是一个演说家，我演讲的题目是%s' % (self.name, self.topic))


class Sample(Speaker, Student):   #多重继承
    a = ''

    def __init__(self, n, a, w, g, t):
        Student.__init__(self, n, a, w, g)
        Speaker.__init__(self, n, t)


test = Sample('Tim', 30, 50, '大学', 'python')
test.speak()  # 方法名相同，默认调用排在前面的父类的speak（）方法

运算符重载

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

运算符重载是通过重写python的内置方法实现的，即只需要在子类中重写内置方法，我们自定义的实例便可像内建对象一样进行运算符操作了。如果没有进行运算符重载，想让两个实例中的a相加，应该是print（v1.a+v2.a）。

内置函数

class Cat:
    def __init__(self, n):  # 先初始化属性，并执行初始化方法里的函数
        self.name = n
        print('%s说：我来了。' % self.name)

    def __del__(self):  # 程序最后自动调用
        print('%s说：我走了。' % self.name)

    def __str__(self):   # 打印变量时调用
        return '我是%s' % self.name


tom = Cat('kj')
print(tom)  # 调用str
print(tom.name)
del tom  # 主动调用del
print('*'*10)

文件操作

写文件
如果文件不存在，会自动创建文件

with open('test.txt', 'wt') as out_file:
    out_file.write('hello world,hello python~')

file = open('test.txt', mode='w')
file.write('how are you?')
file.close()

l = ['i am fine,thank you~\n', 'bye bye~']
file.writelines(l)    # 把l中的内容全部写入文件中，多行一次性写入
file.close()

读文件

with方式操作文件，可以不用关闭文件，会自动关闭文件

with open('test.txt', 'rt') as in_file:
    text = in_file.read()
print(text)

读文件

file = open('test.txt', mode='r', encoding='utf_8')
ret = file.read()   # 默认一次性读取文件的全部内容
print(ret)

ret = file.read(2)  # 只读取两个字节的内容
print(ret)
file.close()

ret = file.readline()  # 每次读取一行

ret = file.readlines()  # 全部读取，内容保存到列表中，每一行是一个元素

for line in file:  # 循环读取
    print(line)

format()格式化字符串 基本语法是通过 {} 和 : 来代替以前的 % 。
方式一

print('网站名：{name},地址：{url}'.format(name='菜鸟教程', url='www.runoob.com'))

方式二 通过字典设置参数

site = {'name': '菜鸟教程', 'url': 'www.runoob.com'}
print('网站名：{name},地址：{url}'.format(**site))  # site前面双星号不清楚含义

方式三 通过列表索引设置参数

my_list = ['菜鸟教程', 'www.runoob.com']
print('网站名：{0[0]},地址{0[1]}'.format(my_list))