Python语言学习笔记之一（基础语法）

最新推荐文章于 2023-01-18 16:51:45 发布

garagong

最新推荐文章于 2023-01-18 16:51:45 发布

阅读量444

点赞数

分类专栏： Python 文章标签： python pycharm PIP

本文链接：https://blog.csdn.net/gyshun/article/details/84671683

版权

Python 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

本课程对于有其它语言基础的开发人员可以参考和学习，同时也是记录下来，为个人学习使用，文档中有此不当之处，请谅解。

1 注释

单行注释
Python编程语言的单行注释常以#开头，单行注释可以作为单独的一行放在被注释代码行之上，也可以放在语句或者表达式之后。
实例：

print ("hello world!");     #您好，世界

多行注释
Python中多行注释使用三个单引号（’’’）或者三个双引号（”””）来标记，而实际上这是多行字符串的书写方式，并不是Python本身提倡的多行注释方法。
实例：
‘’’
这是多行注释，使用单引号。
这是多行注释，使用单引号。
‘’’
“”"
这是多行注释，使用双引号。
这是多行注释，使用双引号。
“”"
代码演示：

if __name__ == '__main__':
        print("Hello World！！")
        # demo_string()
        demo_operation()

2 字符串

def demo_string():
    str = 'hello world!!'
    print(str.capitalize())
    print(str.replace('world','nowcoder!'))
    print(1,str.lstrip())
    str2 = "gyshun0"
    print(str2.startswith("gy"))
    str3 = "tongtong"
    print(str3.endswith("x"))
    print(str+str2+str3)
    print(len(str3))
    print("-".join(["A","B","C"]))
    print(str.split("w"))
    print(str.find("lo"))

if __name__ == '__main__':
        print("Hello World！！")
        demo_string()

3 运算符

在这里插入图片描述

4 内置函数

4.1 print函数

python2.x和3.x中的输出语句有着明显不同

2.x中的print不是个函数，输出格式如下：

1 Python 2.7.12+ (default, Aug  4 2016, 20:04:34) 
2 [GCC 6.1.1 20160724] on linux2
3 Type "help", "copyright", "credits" or "license" for more information.
4 >>> print "There is only %d %s in the sky."%(1,'sun')
5 There is only 1 sun in the sky.

3.x中的print成了函数，输出格式如下：

1 Python 3.5.2+ (default, Aug  5 2016, 08:07:14) 
2 [GCC 6.1.1 20160724] on linux
3 Type "help", "copyright", "credits" or "license" for more information.
4 >>> print("There is only %d %s in the sky."%(1,'sun'))
5 There is only 1 sun in the sky.

4.2其它内置函数

代码如下：

def dem_buildfunction():
    # 求最大值与最小值
    print(1,max(5,3),min(6,2))
    # 求字符串的长度，求数组的长度
    print(2,len("xxxx"),len([1,2,3,4]))
    # 求绝对值
    print(3,abs(-2))
    # 返回数组，步长为3
    print(4,range(1,10,3))
    # 查找list的目录
    print(5,dir(list))
    x = 2
    #计算
    print(6,eval("x+3"))
    print(7,chr(97),ord("a"))

5 控制流

if/else条件语句：

def dem_controlflow():
    score = 65
    if score >90 :
        print("A")
    elif score >60 :
        print("B")
    else:
        print("C")
if __name__ == '__main__':
    dem_controlflow()

while循环

def deme_controlflow():
    score = 65
    while score <100 :
        print(score)
        score += 10
if __name__ == '__main__':
    deme_controlflow()

结果：
65
75
85
95
for循环

def deme_controlflow():
    for i in range(0,10,2):
        print(i)

if __name__ == '__main__':
    deme_controlflow()

结果：
0
2
4
6
8
对于Python也有一些关于循环的关键字：continue、break、pass

continue:是直接跳转到下面的循环，不退出
break:是直接退出循环
pass:是直接跳过循环，下次再次补充
代码如下：

def deme_controlflow():
    for i in range(0,10,2):
        if i == 0 :
            # print(3,0)
            pass  #doSpeeial
        if i < 5 :
            continue
        print(i)
        if i == 6 :
            break
if __name__ == '__main__':
    deme_controlflow()

6 数据结构

6.1 List数组

def demo_list():
    lista = [1,2,3] #定义数组
    print(1,lista)
    listb = ['a',1,'c',1.1] #List可以存放多种类型的数据
    print(2,listb)
    lista.extend(listb) #两个数组直接进行连接
    print(3,lista)
    print(4,len(lista)) #求数组的长度
    print(5,'a' in listb) #判断数组中有没有对应的数据
    lista = lista + listb #两个数组进行连接操作
    print(6,lista)
    listb.insert(0,'WWWW') #在数据的指定位置插入一个数据
    print(7,listb)
    listb.pop(1) #在数组中指定的索引弹出一个数据
    print(8,listb)
    listb.reverse() #数组中的数据进行反转操作
    print(9,listb)
    print(10,listb[0],listb[1]) #输出单个数组的数据
    # listb.sort() # 排序
    print(11,listb)
    listb.sort(reverse=True) #逆序
    print(12,listb)
    print(13,listb * 2) #数组中的数据翻番,
    print(14,[0] * 14) #创建14个数据为0的一个数组
    listb.append(4)
    print(listb)
if __name__ == '__main__':
    # deme_controlflow()
    demo_list()

6.2 tuple元组

tuple不可以修改，但可以拼接使用+操作符，它与list的区别是：

6.2.1 定义结构的区别

tuple定义是用（），list的定义是用[]，字符数组的定义有以下区别，如下代码：

tuple 
tup1 = (‘physics’, ‘chemistry’, 1997, 2000); 
tup2 = (1, 2, 3, 4, 5 ); 
tup3 = “a”, “b”, “c”, “d”; 
list 
list1 = [‘physics’, ‘chemistry’, 1997, 2000]; 
list2 = [1, 2, 3, 4, 5 ]; 
list3 = [“a”, “b”, “c”, “d”];

6.2.2 tuple是不可改变的list

tuple好像只是不可变的list. 但是如果把python的这种语法特性放到特定的语义当中,两者的差别便体现出来了,如下代码：

>>>import time 
>>>time.localtime() 
Local current time : time.struct_time(tm_year=2013, tm_mon=7, 
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

可以看到上面的time.localtime() 方法输出的结果是一个tuple,它是不可变的.而它要表达的意思则是当前时间,对于一个具体的时刻来说,每一个数值代表的意思也是一一对应不变得,这跟tuple的语法特点也是相对应的。
类似的情况还有试用sql查找输出的结果result 也是tuple,而sql结果的tuple中的每个数值,跟数据库中的字段也是一一对应的。
相反,sql结果集resultSet 中每一个成员代表一个搜索结果,他们相互的关系是对等的,是可以相互替换的,这也是python中给list中的成员的定位。

6.2.3 dictionary

在JAVA语言中，HashMap相当于dictionary，都是存放键值对。
dictionary中的方法与HashMap中差不多
dictionary的键值对中的值也可以存放函数
代码如下：

def sub(a,b):
    return a -b
def sum(a,b):
    return  a + b
def demo_dictionary():
    dict = {1:1,2:3,4:5,5:9}
    # 获取Dictionary中的键和值
    print(1,dict.keys(),dict.values())
    print(2,dict.get(1))
    #循环遍历字典中的所有键值对
    for key,value in dict.items():
        print("kye-value",key,value)
    # 字典中也可以存放的值为函数
    dictb = {"+": sum, "-":sub}
    print(dictb["+"](1,2))
    print(dictb["-"](1,2))
    dictb["*"] = "X"
    print(dictb)
    dict.pop(4)
    print(dict)
    del dict[1]
    print(dict)
if __name__ == '__main__':
    # deme_controlflow()
    # demo_list()
    demo_dictionary()

6.2.4 set 集合

Set和List一样，就是一个集合，与数学中的集合一样，有集合的交集、并集
如下代码：

def demo_set():
    seta = set((1,2,3))
    setb = set((2,3,4))
    #求交集(两种方式)
    print(1,seta.intersection(setb),seta & setb)
    #求并集(也是两种方式)
    print(2,seta.union(setb),seta | setb)
    #通过减法送去相同的集合元素
    print(3,seta-setb)
    #新增元素
    seta.add("X")
    print(4,seta)
    print(len(seta))
if __name__ == '__main__':
    # deme_controlflow()
    # demo_list()
    # demo_dictionary()
    demo_set()

结果：
1 {2, 3} {2, 3}
2 {1, 2, 3, 4} {1, 2, 3, 4}
3 {1}
4 {1, 2, 3, ‘X’}
4

6 面向对象支持

面向对象的特点：封装、继承、多态

6.1 repr和str区别

先看下面的例子再解释：

class Test(object):
    def __init__(self, value='hello, world!'):
        self.data = value
>>> t = Test()
>>> t
<__main__.Test at 0x7fa91c307190>
>>> print t
<__main__.Test object at 0x7fa91c307190>
# 看到了么？上面打印类对象并不是很友好，显示的是对象的内存地址
# 下面我们重构下该类的__repr__以及__str__，看看它们俩有啥区别
# 重构__repr__
class TestRepr(Test):
    def __repr__(self):
        return 'TestRepr(%s)' % self.data
>>> tr = TestRepr()
>>> tr
TestRepr(hello, world!)
>>> print tr
TestRepr(hello, world!)
# 重构__repr__方法后，不管直接输出对象还是通过print打印的信息都按我们__repr__方法中定义的格式进行显示了
# 重构__str__
calss TestStr(Test):
    def __str__(self):
        return '[Value: %s]' % self.data
>>> ts = TestStr()
>>> ts
<__main__.TestStr at 0x7fa91c314e50>
>>> print ts
[Value: hello, world!]

__repr__和__str__这两个方法都是用于显示的，__str__是面向用户的，而__repr__面向程序员。

打印操作会首先尝试__str__和str内置函数(print运行的内部等价形式)，它通常应该返回一个友好的显示。
repr__用于所有其他的环境中：用于交互模式下提示回应以及repr函数，如果没有使用__str，会使用print和str。它通常应该返回一个编码字符串，可以用来重新创建对象，或者给开发者详细的显示。
当我们想所有环境下都统一显示的话，可以重构__repr__方法；当我们想在不同环境下支持不同的显示，例如终端用户显示使用__str__，而程序员在开发期间则使用底层的__repr__来显示，实际上__str__只是覆盖了__repr__以得到更友好的用户显示。

6.2 继承：

代码如下：

# 定义一个类
class User:
    type = "USER"
    def __init__(self,name,uid):
        self.name = name
        self.uid = uid
    def __repr__(self):
        return "I am "+ self.name+" "+str(self.uid)
# 定义一个类，并继承User，覆盖repr方法
class Guest(User):
    def __repr__(self):
        return "I am guest:"+self.name+"  "+str(self.uid)
# 定义一个类，继承User，__init__方法进行了重写
class Admin(User):
    type = "ADMIN"
    def __init__(self,name,uid,group):
        User.__init__(self,name,uid)
        self.group = group

    def __repr__(self):
        return  "I am Admin:"+self.name +" "+str(self.uid) + "  "+self.group

# 这个一个方法（函数），相当于JAVA中的工厂模式,同时创建一个User或者Admin
def creat_user(type):
    if type == "USER":
        return User("U1",1)
    elif type =="ADMIN":
        return Admin("a1",2,"g1")
    else:
        raise ValueError("error")
if __name__ == "__main__":
    user1 = User("u1",1)
    print(user1)
    guest1 = Guest("u2",2)
    print(guest1)
    admin1 = Admin("u3",3,"管理员");
    print(admin1)
    print(creat_user("USER"))

7 异常处理

代码演示：

def demo_exception():
   try:
     print(2/1)
     print(2/0)
     raise Exception('Raise Error', 'NowCoder')
   except Exception as e:
     print('error:', e)
   finally:
     print('clean up')

if __name__ == "__main__":
    demo_exception()

8 常用的类和函数

8.1 random随机类

代码演示：

import random
def demo_random():
    random.seed(1)
    print(1,random.random())
    print(2,random.randint(0,100))
    print(3,random.choice(range(0,100,10)))
    # 这个是随机抽样，抽出4个值（在0到100中）
    print(4,random.sample(range(0,100),4))
    a = [1,2,3,4,5]
    # 把一个队列进行随机打乱
    random.shuffle(a)
    print(5,a)
if __name__ == "__main__":
    demo_random()