学习笔记--《python 编程入门经典》

python 编程入门经典

1.编程基础与字符串

  • python是解释性语言，不用了解计算机内部细节。

  • python shell是一种查看运行中的python代码的方式。好处是可以让程序员在自己创建的上下文环境中进行实验。

  • 单引号与双引号、三层引号是等价的，都是表示字符串。但灵活应用可以减少转义字符的使用，简化字符串定义。

    • 三引号可以定义多行数据，不用手动加换行符。

  • 字符串串联方法。

    copy
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    "hello" " world"     #法1
"hello"+" "+"word"   #法2
print("hello","word") #法3 会自动加空格
print("hello"+"word") #法4 没有空格
"hello %s" % ("world")    #法5 %s字符串格式说明符
"hello %s%s" % ("world"," !")
"hello %10s%s" % ("world","!")  #不足10，左边补空格

  • 字符串具有分片功能

    copy
    • 1
    • 2
    string = "name"
print(string[0])  #输出n

2.数值与运算符

  • pyhotn有三种数值类型：整型、浮点型和虚数。使用type可以查看数值的类型。
    • 虚数表示：数字后面加一个j,如a=12j+1。
  • C语言中的格式说明符，适用pyhton。

3.变量

  • python提供六种基本类型：数值、字符串、元组、列表、集合、字典。

  • 元组tuple：不可更改的数据序列。创建时被圆括号包围。

    • 可以单独的访问每个值。

    • 可以使用内置函数len()获取长度。

    • 也可以嵌套元组。

    • 若要创建只有一个元素的元组，最后需要加上逗号，否则就是字符串。

      copy
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      filler = ("string","filled","by a","tuple")
print(filler[3])
print(len(filler))
b = (("in","tuple"),"outer","tuple") #嵌套元组
print(b[0][1])  #输出第一个tuple
c = ("tuple",)    #逗号不能省略

  • 列表list：可以更改的数据序列。创建时用方括号包围。

    • 也可以像元组一样随机访问，但可以修改。

    • 可以使用append()函数向末尾添加一个新元素。

    • 可以使用extend()函数向末尾添加另一个列表。

    • 适用pop()方法移除元素。

    • [头下标:尾下标] ，就可以截取相应的列表

      copy
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      breakfast = ["coffee","tea","toast","egg"]
breakfast[2] = "youtiao"    #可以修改
breakfast.append("baozi")
breakfast.extend(["milk","peanut"]) #列表元素添加
breakfast.pop(2)    #删除2号元素并返回该元素值
breakfast[1:3]

  • 字典dict：以名称索引的分组数据。创建时用大括号。类似于c++中的vector。

    • 允许一个键下有多个值。

      copy
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      dicta = {}   #空字典
dicta["breakfast"] = "baozi"
dicta["lunch"] = "rice"
dicta["dinner"] = "zhou"
#小括号可以省略，一个键多个值(组成一个元组)
dicta["persons"] = ("cr","xm")

  • 集合set，与字典类似，不过没有值，只有键；是不包括重复元素的数据集。适用set()创建

    copy
    • 1
    • 2
    a=['a','a','b','b','c']   #列表
ss=set(a)       #创建集合ss 结果为{'a','b','c'} 删除了重复元素

  • 其他类型None,True(非0值),False(0)。

  • 序列类型的共有属性（字典是非序列类型，因为它没有特定的顺序）

    • 对序列分片

      copy
      • 1
      • 2
      • 3
      breakfast[1:3]    #列表分片
string[2:4]       #字符串分片
filler[0:3]       #元组分片

4.pyhton语言基础

  • 对真值和假值取反 not

    copy
    • 1
    • 2
    not True    #等于False
not 1       #等于False

  • 判断语句

    copy
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    a = 3
if a > 3:
  print("a > 3")
elif a < 3:
  print("a <= 3")
else:
  print("a = 3")

  • 循环for ... in ...，in 后面提供一个序列，如列表、元组或者range()

    • for循环与while循环可以添加else，在非break结束的循环时执行。

  • 异常

    • 也可以通过raise显示地引发异常
    copy
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    try:
  <语句>        #运行别的代码
except <名字>：
  <语句>        #如果在try部份引发了'name'异常
except <名字>,<数据>:
  <语句>        #如果引发了'name'异常，获得附加的数据
else:
  <语句>        #如果没有异常发生

  • python文件第一行应该是 #!/usr/bin/env python，这将使得UNIX、LINUX能够运行这些脚本。通过 ./xxx.py 的方式，不用每次都用python xx.py执行。

    • 注意：需要先给该文件加上可执行权限。chmod a+x xxx.py

  • 在函数中描述函数，文档字符串。

    copy
    • 1
    • 2
    • 3
    • 4
    • 5
    def add(a,b = 1):   #可以加默认值
  """add two integer a and b"""   #用 add.__doc__ 可以输出
  c = a + b
  return c
print("%s" % add.__doc__)         #使用dir()可以查看对象的所有属性
    • 对于参数，可以用type()函数来判断参数类型，从而选择执行。
    • 可以嵌套函数，但不能被外部直接使用。

5.类与对象

  • __private_attrs，两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

  • __private_method，两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

    • self代表的是类的实例，也可以使用this，但一般用self。
    copy
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    #!/usr/bin/env python
class MyClass:
    """一个简单的类实例"""
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    i = 12345
    def f(self):
        return 'hello world'
    def __init__(self):   #构造方法
      i = 1234544
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

  • 继承

    copy
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    class DerivedClassName(BaseClassName):  #单继承
  <statement-1>
  ...
  <statement-N>
class DerivedClassName(Base1, Base2, Base3):  #多继承
  <statement-1>
  ...
  <statement-N>

  • 重写父类方法

    copy
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    #!/usr/bin/env python

class Parent:        # 定义父类
  def myMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
  def myMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

6.组织程序

  • 模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。

    • 需要将该模块文件所在位置加入sys.path中，否则会找不到该文件。

    • sys.path是一个普通的列表，可以直接用append()或extend()添加。

      copy
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      #!/usr/bin/env python
import sys
from Parent import myMethod   #另一种导入方式
print('命令行参数如下:')
for i in sys.argv:
  print(i)
print('\n\nPython 路径为：', sys.path, '\n')

  • 包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

    • 简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。

      copy
      • 1
      • 2
      • 3
      • 4
      |--package_runoob   #import该包名就能自动运行__init__.py，从而引入其他模块
  |-- __init__.py     #在其中引入runoob1、runoob2模块
  |-- runoob1.py
  |-- runoob2.py

  • sys.modules.keys() 能输出当前加载的所有模块。

  • if __name__ == '__main__': 只有在文件作为脚本时才能执行，被其他文件调用时不能执行。放在末尾，可用于测试模块和包。

本文作者：oniisan

本文链接：https://www.cnblogs.com/oniisan/p/pythonBasic.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   Oniisan_Rui  阅读(77)  评论(0)  编辑  收藏  举报
💬
评论
📌
收藏
💗
关注
👍
推荐
🚀
回顶
收起
点击右上角即可分享
微信分享提示