IT序号网

python基础学习笔记1知识解答

luoye 2021年06月13日 编程语言 144 0
hello word!
脚本helloword.py 
#!/usr/bin/env python 
print('Hello World!')
两种执行方式:
1. $python helloword.py
   Hello World!
 
2. $./ helloword.py
   Hello World!
 
注意:脚本首行就是给执行方式2,指定解释器;就和写shell 脚本时首行指定 bash一样;
          如果用第一种方式,执行。首行不写也可以正确执行噢!通常情况还是要写上去的;
 
基本数据类型
变量不需要声明
>>>a = 10 
>>>print a 
>>>print type(a)
输出会如下:
10
<type 'int'>
这里要注意的是内置函数 type()查询变量的类型;
当然变量不需要声明,所以当你想在a中放入其他类型数据也是可以的噢;
>>>a = 1.3 
>>>print a,type(a)
输入如下:
1.3 <type 'float'>
 
序列 sequence
sequence是一组有顺序的元素的集合;
序列有两种:tuple(定值表;也有翻译为元祖) 和list(表)
>>>s1 = (2, 1.3, 'love', 5.6, 9, 12, False)         # s1是一个tuple 
 
>>>s2 = [True, 5, 'smile']                          # s2是一个list 
 
>>>print s1,type(s1) 
 
>>>print s2,type(s2)
输出:
(2, 1.3, 'love', 5.6, 9, 12, False)  <type 'tuple'>   
[True, 5, 'smile']  <type 'list'>   
 
注意:tuple 与 list 的区别是tuple 在给定之后不可改;而list可更改
         判定是tuple,或者 list 是通过()和[]来判定的噢!
 

一个序列作为另一个序列的元素

>>>s3 = [1,[3,4,5]]

空序列

>>>s4 = []
 
序列元素的引用更改:
序列的引用通过s[<int>]实现, int为下标s为序列符号
例如上面:取s1 的第二个元素 s2的第三个元素
>>>print s1[1] 
1.3 
>>>print s2[2] 
smile 
>>>print s3[1][2]                   #有点二维数组的味道 
5
注意:下标也是从0开始的噢;
 
 
其他引用方式:
范围引用: 基本样式[下限:上限:步长]
重点:不包括上限元素本身噢,如果有上限;
 
>>>print s1[:5]        # 从开始到下标4 (下标5的元素 不包括在内) 
>>>print s1[2:]        # 从下标2到最后 
>>>print s1[0:5:2]     # 从下标0到下标4 (下标5不包括在内),每隔2取一个元素 (下标为0,2,4的元素) 
>>>print s1[2:0:-1]    # 从下标2到下标1
尾部元素引用
>>>print s1[-1]             # 序列最后一个元素 
>>>print s1[-3]             # 序列倒数第三个元素
同样,如果s1[0:-1], 那么最后一个元素不会被引用 (再一次,不包括上限元素本身)
 
字符串是一个tuple;
字符串是一种特殊的元素,因此可以执行元组的相关操作
>>>str = 'abcdef' 
>>>print str[2:4]
运算
数学运算

>>>print 1+9        # 加法

>>>print 1.3-4      # 减法

>>>print 3*5        # 乘法

>>>print 4.5/1.5    # 除法

>>>print 3**2       # 乘方     

>>>print 10%3       # 求余数
 
判断返回True/False
>>>print 5 in [1,3,5]       # 5是list [1,3,5]的一个元素
==, !=, >, >=, <, <=, in
 
逻辑运算
and, or, not 与或非
 
缩进和选择
Python最具特色的是用缩进来标明成块的代码;
用缩进空格来表示隶属关系;

if语句之后的冒号

以四个空格的缩进来表示隶属关系, Python中不能随意缩进

if  <条件1>:

    statement

elif <条件2>:

    statement

elif <条件3>:

    statement

else:

    statement
 
循环
for循环
基本构造是
 
for 元素 in 序列: 
    statement
举例:
for a in [3,4.4,'life']:
    print a
打印这个list中每一个元素;
 
range(),函数来建list表;
idx = range(5)
print idx
输出:
[0, 1, 2, 3, 4]
这个函数的功能是新建一个表。这个表的元素都是整数,从0开始,下一个元素比前一个大1, 直到函数中所写的上限 ( 不包括该上限本身
举例:
for a in range(10):
    print a**2
 
while循环
while 条件:
    statement
while会不停地循环执行隶属于它的语句,直到条件为假(False)
 
举例
while i < 10:
    print i
    i = i + 1
 
中断循环
continue   # 在循环的某一次执行中,如果遇到continue, 那么跳过这一次执行,进行下一次的操作
break      # 停止执行整个循环
举例
for i in range(10):
    if i == 2: 
        continue
    print i
输出除2以外的0-9;
 
for i in range(10):
    if i == 6:       
        break
    print i
输出0-5,6的时候已经跳出所以不输出;
 
函数
函数最重要的目的是方便我们重复使用相同的一段程序。
函数的定义
def square_sum(a,b):
    c = a**2 + b**2
    return c

这个函数的功能是求两个数的平方和。

首先,def,这个关键字通知python:我在定义一个函数。square_sum是函数名。

括号中的a, b是函数的参数,是对函数的输入。参数可以有多个,也可以完全没有(但括号要保留)

c = a**2 + b**2        # 这一句是函数内部进行的运算

return c               # 返回c的值,也就是输出的功能。Python的函数允许不返回值,也就是不用return。

return可以返回多个值,以逗号分隔。相当于返回一个tuple(定值表)。

return a,b,c          # 相当于 return (a,b,c)
函数参数的传递
变量传递是值传递
表传递是  地址传递
 
面向对象的基本概念
Python使用类(class)和对象(object),进行面向对象(object-oriented programming,简称OOP)的编程
 
相近对象归为类
定义鸟类:
class Bird(object): 
    have_feather = True 
    way_of_reproduction  = 'egg'
 
创建对象
summer = Bird() 
print summer.way_of_reproduction
可怜的summer,你就是个有毛产的蛋货,好不精致。
 
动作
class Bird(object):      #object说明Bird类没有父类                             
   have_feather = True
way_of_reproduction = 'egg' def move(self, dx, dy): position = [0,0] position[0] = position[0] + dx position[1] = position[1] + dy return position summer = Bird() print 'after move:',summer.move(5,8)
注意: 它的参数中有一个self,它是为了方便我们引用对象自身。方法的第一个参数必须是self,无论是否用到。
    dx, dy表示在x、y两个方向移动的距离。move方法会最终返回运算过的position。
         在最后调用move方法的时候,我们只传递了dx和dy两个参数,不需要传递self参数(因为self只是为了内部使用)
 
我的summer可以跑了。
 
子类
类别本身还可以进一步细分成子类比如说,鸟类可以进一步分成鸡,大雁,黄鹂。
在OOP中,我们通过继承(inheritance)来表达上述概念。
 
class Chicken(Bird): 
    way_of_move = 'walk' 
    possible_in_KFC = True 
 
class Oriole(Bird): 
    way_of_move = 'fly' 
    possible_in_KFC = False 
 
summer = Chicken() 
print summer.have_feather 
print summer.move(5,8)

新定义的鸡(Chicken)类的,增加了两个属性:移动方式(way_of_move),可能在KFC找到(possible_in_KFC)

在类定义时,括号里为了Bird。这说明,Chicken是属于鸟类(Bird)的一个子类,即Chicken继承自Bird。自然而然,Bird就是Chicken的父类。Chicken将享有Bird的所有属性。
尽管我只声明了summer是鸡类,它通过继承享有了父类的属性(无论是变量属性have_feather还是方法属性move)
 
注意:若定义类是括号中为object则该类没有父类;
 
self
定义类的方法是,必须有self,这个参数表示某一具体的对象;可以通过self,调用类的属性;对象的性质,也是通过self来改变的。
class Human(object): 
    def __init__(self, input_gender): 
        self.gender = input_gender 
    def printGender(self): 
        print self.gender 
li_lei = Human('male') # 这里,'male'作为参数传递给__init__()方法的input_gender变量。 
print li_lei.gender 
li_lei.printGender()
__init__()方法
是一个特殊的方法,python有一些特殊的方法,python会特殊的对待他们。特殊方法的特点是前后有两个下划线。
例子:
class happyBird(Bird): 
    def __init__(self,more_words): 
        print 'We are happy birds.',more_words 
summer = happyBird('Happy,Happy!')
屏幕上打印:
We are happy birds.Happy,Happy!
 
__init__()方法,是初始化的过程;python在创建对象时,自动调用这个方法,这个过程叫做初始化的过程。
 
everything is object 
 
dir()
查询一个类或者对象所有属性
help()
查询说明文档
 
list是一个类,是python已经定义好的一个类,当我们新建一个表时,如:
>>>nl = [1,2,5,3,5]
实际上,n1是类list的一个对象
那么list既然是一个类,那我们n1对象就可以调用它的方法:
>>>print nl.count(5)        # 计数,看总共有多少个5 
>>>print nl.index(3)        # 查询 nl 的第一个3的下标 
>>>nl.append(6)             # 在 nl 的最后增添一个新元素6 
>>>nl.sort()                # 对nl的元素排序 
>>>print nl.pop()           # 从nl中去除最后一个元素,并将该元素返回 
>>>nl.remove(2)             # 从nl中去除第一个2 
>>>nl.insert(0,9)           # 在下标为0的位置插入9
 
运算符是特殊方法
使用dir(list)的时候,能看到一个属性,是__add__()。从形式上看是特殊方法(下划线,下划线)。
它特殊在哪呢?这个方法定义了"+"运算符对于list对象的意义,两个list的对象相加时,会进行的操作。
>>>print [1,2,3] + [5,6,9]

运算符,比如+, -, >, <, 以及下标引用[start:end]等等,从根本上都是定义在类内部的方法。

尝试一下

>>>print [1,2,3] - [3,4]

会有错误信息,说明该运算符“-”没有定义。现在我们继承list类,添加对"-"的定义
class superList(list): 
    def __sub__(self, b): 
        a = self[:]     # 这里,self是supeList的对象。由于superList继承于list,它可以利用和list[:]相同的引用方法来表示整个对象。 
        b = b[:]        
        while len(b) > 0: 
            element_b = b.pop() 
            if element_b in a: 
                a.remove(element_b) 
        return a 
 
print superList([1,2,3]) - superList([3,4])
内置函数len()用来返回list所包含的元素的总数。内置函数__sub__()定义了“-”的操作:从第一个表中去掉第二个表中出现的元素。如果__sub__()已经在父类中定义,你又在子类中定义了,那么子类的对象会参考子类的定义,而不会载入父类的定义。任何其他的属性也是这样。
 
总结
  • 内置函数type(),查询变量类型
  • 序列sequence
    • 区别tuple,不可更改,list可更改
    • tuple用小括号,list用中括号
    • tuple: 定值表(元组)
      • s1=(2,1.3,'love',False,12)
    • list:表
      • s1=[Ture,5,'simple']
        • s1[1]值为5
      • s3=[1,[2,3,4]]
        • s3[1][0]值为2
    • 引用方式
      • [下限:上限:步长]
        • 注意如果有上限,是不含上限本身的。
        • s1[:5] # 从开始到下标4 (下标5的元素 不包括在内)
        • s1[2:] # 从下标2到最后
        • s1[0:5:2]     # 从下标0到下标4 (下标5不包括在内),每隔2取一个元素 (下标为0,2,4的元素)
        • s1[2:0:-1] # 从下标2到下标1
      • 尾部元素引用
        • s1[-1] # 序列最后一个元素
        • s1[-3] # 序列倒数第三个元素
    • 字符串是一个tuple,因此也使用上面引用方式
  • 判断返回
    • print 5 in [1,3,5],返回TRUE
  • 语法
    • 使用缩进表示隶属关系
    • if <condition>:      注意冒号
    • 循环
      • for 元素 in 序列:    注意冒号
      • range()函数来建立list表
      • while
    • 函数
      • def squeare_sum(a,b):
  • 面向对象
    • 定义类->创建对象->对象引用类属性
    • 类中的方法第一个参数必须是self,无论是否用到。方便自身引用。
    • object作为没有父类的 类
    • __init__()方法,是初始化的过程;python在创建对象时,自动调用这个方法,这个过程叫做初始化的过程。
  • dir():查看对象或者类的所有属性;
  • help():查看类或对象的帮助信息;
  • list类的方法
    • >>>print nl.count(5) # 计数,看总共有多少个5
    • >>>print nl.index(3) # 查询 nl 的第一个3的下标
    • >>>nl.append(6) # 在 nl 的最后增添一个新元素6
    • >>>nl.sort() # 对nl的元素排序
    • >>>print nl.pop() # 从nl中去除最后一个元素,并将该元素返回
    • >>>nl.remove(2) # 从nl中去除第一个2
    • >>>nl.insert(0,9) # 在下标为0的位置插入9
  • 如果属性或方法已经在父类中定义,你又在子类中定义了,那么子类的对象会参考子类的定义,而不会载入父类的定义。

发布评论
IT序号网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

Docker 限制容器资源知识解答
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。