python语法基础-长期维护-20191211

python语法基础

 

###############python基础的学习方法################

几个决定：

1，以我自己的回忆为主，不可以妄想一次性就整理清楚，
2，结合博客的整理的方式
3，结合网上的文档，这是一个主要方式
4，结合网上的视频，但是视频作为辅助，不要为了看视频而看视频，要注意思维方式的养成，
5，结合每天都要写300行-500行代码，年限不能说明问题，最终还是看写代码的能力，用才能记忆深刻，否则看视频，你是学不会代码的，要强调实战，动手为王，不然就要有多远滚多远，
6，结合编程逻辑思维，要精确，要讲究逻辑思维，
7，学习方法：问题驱动，基础先行，实例和实践相结合的方式，
8，研究定位：研究python3，使用pycharm

 

###############   第一个python程序   ###############

print("hello python")  # 打印hello python

# 分析这么一句代码：
# 1，print是一个函数，
# 2，双括号是指函数的调用，
# 3，hello python是我们传递的数据，
# 4，双引号表示这是一个字符串，
# 5，#号后面是注释，
# 6，python代码区分大小写，Print(),这种就不行，
# 7，python是严格对齐的，前面不能有空格
################
# 三引号使用
# print("""hello
#       python""")  # 这是换行的字符串
# 多行注释也可以使用三引号
"""
多行注释
"""

 

###############   常量变量，标识符关键字    ###############

num=13
num=input("请输入一个数字：")  # 输入
print(num) # 输出
print(type(num))  # 数据类型
print(id(num))  # 内存地址，
# 学习几个基本的函数方法，input输入，print输出，type类型，id内存地址，


"""
分析这段代码:
常量变量，
1，num就是一个变量，
2，13就是一个常量，13=13 # 13是常量不能被赋值，
3，区分，变量是可以被赋值的，常量是不能被赋值的，
4，等号就是赋值的意思，

标识符关键字，
num就是一个标识符，这个用于区分其他变量，标识符的硬性要求：
1，标识符只能是字母数字下滑线组成，
2，不能是数字开头，3num=13，这种就不行，
3，标识符不能是关键字，
import keyword
print(keyword.kwlist) #可以查看有哪些关键字，
4，标识符区分大小写，Num=14 


标识符的通用要求
1，就是见名知意，命名有一个有意义的名字，,
2，通用的命名方式有很多种：
类(class)的命名采用大驼峰命名法，首字母大写，如CamelCase；
函数的命名采用下划线分隔的小写字母，如separateed_by_underscores;
变量一般用小驼峰法标识。除第一个单词之外，其他单词首字母大写。myStudentCount;
"""

 

###############    python变量类型    ###############

# 一共是7种数据类型
# 1，Numbers（数字）
num = 10  # int整数
money=123.5  # 浮点数
data=1+2j  # 复数：用来描述平面上的一个坐标，x是1，y是2
# long1=0122L
# long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。
#############################
# 2，Boolean（布尔值）
isnum=True
# 3，String（字符串）
name='andy'
# 4，List（列表）
list1=[1,2,3]
# 5，set集合
set1= {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
# 6，Tuple（元组）
tuple1=(1,2)
# 7，Dictionary（字典）
dict1={"name":"andy","age":18}

 

###############    算数运算符    ###############

# 一共是七种算数运算符
a = 21  
b = 10
print(a+b)  # 加+
print(a-b)  # 减-
print(a*b)  # 乘*
print(a/b)  # 除/
print(a//b)  # 取余%
print(a%b)  # 取商//
print(a**b)  # 幂运算**

 

###############    字符串的基本操作    ###############

name ='andy'
print("my name is "+ name)  # 字符串连接
print(name*2)  # 重复输出字符串
print(name[1])  # 通过索引获取字符串中字符
print(name[0:2])  # 截取字符串中的一部分，遵循左闭右开原则
print('a' in name)  # 成员运算符 - 如果字符串中包含给定的字符返回 True
print('a' not in name)  # 成员运算符 - 如果字符串中不包含给定的字符返回 True
print('my name is %s,age is %d'%(name,18))  # 字符串格式化，%s是字符串，%d是整数

 

###############    字符串的常用内置函数    ###############

str1 = 'andy'
print(str1.capitalize())  # 将字符串的第一个字符转换为大写
print(str1.center(10,'*'))  # 这是把字符串在10个width中显示，空的显示后面的字符
print(str1.count('a',0,len(str1)))  # 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
print(str1.find('a',0,len(str1)))  # 检测字符串中是否包含子字符串 str ，如果指定范围,返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
print(str1.index('a',0,len(str1)))  # 跟find()方法一样，只不过如果str不在字符串中会报一个异常.所以一般还是用find
print(str1.isalnum())  # 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
print(str1.isalpha())  # 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
print(str1.isdigit())  # 如果字符串只包含数字则返回 True 否则返回 False..
print(len(str1))  # 返回字符串长度
print(max(str1))  # 最大，
print(min(str1))  # 最小
print(str1.title())  # 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
print(str1.upper())  # 转换字符串中的小写字母为大写
print(str1.replace("a","A",1))  # 字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
print(str1.split('n',2))  # split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。num -- 分割次数。默认为 -1, 即分隔所有。
seq=('a','d','d','y')
print('-'.join(seq))

 

###############    列表的操作    ###############

list1=['my','name','is','andy']
# 访问列表：切片
print(list1[2])
print(list1[1:3])
print(list1[:-1])
# 更新列表
list1[0]='his'
print(list1)
list1.append('Lee')  # 这是在列表末尾插入元素
print(list1)
list1.insert(1,[1,2,3])  # 这是在指定位置插入元素
print(list1)
# 删除列表元素
del list1[4]
print(list1)
list1.remove(list1[3])
print(list1)
list1.pop()  # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
print(list1)
# +和*，适用于字符串，同样适用于列表
print(list1+list1) # ['his', 'name', 'is', 'his', 'name', 'is']
print(list1*3) # ['his', 'name', 'is', 'his', 'name', 'is', 'his', 'name', 'is']

 

###############    列表的其他常用函数和方法    ###############

list1=['my','name','is','andy']
print(len(list1))
print(max(list1))
print(min(list1))
print(list1.count('my'))  # 统计某个元素在列表中出现的次数
print(list1.index('my'))  # 从列表中找出某个值第一个匹配项的索引位置
print(list1.reverse())  # 反向列表中元素
list2=[4,5,1,2,3]
list2.sort(reverse=True)  # reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
print(list2)
list2.clear()
print(list2)
list3=list1.copy()
print(list3)

 

###############    元组的操作    ###############

# 元组
# 创建空元组
tuple1=()
# 元组只包含一个元素时，需要在后面加逗号
tuple2=(1,)
print(type(tuple2))
# 访问元组
tuple3=(1,2,3)
print(tuple3[2])  # 所以一样可以使用切片的方式
# 修改元组
# 注意：元组里面的元素值是不能被修改的，但是可以进行连接，使用+
tuple4=tuple3+tuple2
print(tuple4)
# 也可以使用*号进行运算
print(tuple3*3)
# 也可以使用in来判断一个元素是否在这个元组内，返回True，和False，
print(3 in tuple3)
# 删除元组
# 元组里面的元素是不允许删除的，但是可以删除整个元组，
del tuple4
print(tuple4)
# 元组的内置函数
# 同样的元组内置函数也有len(),max(),min(),

 

###############    字典的操作    ###############

# 字典
dict1={"name":'andy',"age":18}
# 注意：字典的key必须是唯一的，值可以不是唯一的，
# 访问字典里的值
print(dict1['name'])
# 修改字典的值
dict1['age']=20
print(dict1)
# 往字典里面新增新的值
dict1['sex']='boy'
print(dict1)
# 所以也就是说如果有值就是修改，没有值就是新增，
# 删除字典的值
del dict1['sex']  # 删除某一个元素
dict1.clear()  # 清空字典的值
del dict1  # 删除整个字典，
# 字典的特性
# 字典的键必须不可变，所以可以是数字，字符串，元组，但是列表就不行，

 

###############    字典的内置函数    ###############

dict1={"name":'andy',"age":18}
# copy()
dict2=dict1.copy()  # 返回一个字典的浅复制
print(dict2)
# fromkeys()
seq=['name','age'] 
dict3=dict.fromkeys(seq,10) # 创建一个字典，以序列中的元素作为键，第二个参数是默认的值，不写默认是none print(dict3) # {'name': 10, 'age': 10}
# get()
print(dict1.get('name','NAN'))  # get() 函数返回指定键的值，如果值不在字典中返回默认值。
# print(dict1['name2'])  # 这种切片的方式会如果没有这个键会报错，所以一般是使用get的方式取值，不报错，
# dict1.keys()
dict1_key=dict1.keys()
print(dict1_key)  # dict_keys(['name', 'age'])
print(type(dict1_key))  # 
print(list(dict1_key))  # 可以转换为列表，
# dict1.items()
dict1_items=dict1.items()
print(dict1_items)  # 返回的是列表形式，里面的元素都是键值对构成的元组
# dict1.values()
dict1_values=dict1.values()
print(dict1_values)  # 返回一个迭代器，可以使用 list() 来转换为列表
# dict1.pop()
dict1_pop=dict1.pop('name2','默认值')  # 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
print(dict1_pop)

 

###############    if条件控制语句    ###############

# 以下实例 x 为 0-99 取一个数，y 为 0-199 取一个数,如果 x>y 则输出 x，如果 x 等于 y 则输出 x+y，否则输出y
import random
x=random.randint(0,100)
y=random.randint(1,100)
print(x,y)
print('#'*30)
if x>y:
    print(x)
elif x==y:
    print(x+y)
else:
    print(y)

 

###############    while循环语句    ###############

# 实例:使用了 while 来计算 1 到 100 的总和：
# a=0
# total=0
# while a<=100:
#     total+=a
#     print(a)
#     a+=1
# print(total)

# 无限循环
# 加法计算器

while True:
    print('1：加法   q：退出')
    option=input('请输入你的操作：')
    if option=='1':
        a=int(input('请输入a:(输入000退出)'))
        b= int(input('请输入b(输入000退出)'))
        c=a+b
        print('a+b=%d'%c)
    if option=='q':
        break

 

###############    for循环语句    ###############

# 遍历列表
list1=['c','c++','java','python']
for i in range(4):  # range是0-4，左开右闭，
    print(i,list1[i])

# 0-100的和
sum=0
for i in range(0,101):
    sum+=i
    print(i)
print(sum)

 

###############    函数的定义及四种参数    ##############

########################
# 这种没有参数
def hollo1():
    print('hello world')
hollo1()

###################
# 这是必需参数
def hollo2(name):
    print('hello world')
    print(name,'在唱歌...')
hollo2('andy')

#######################
def hollo3(age,name):
    print('hello world')
    print('我今年%d岁了'%age)
    print(name,'在唱歌...')
hollo3(name='andy',age=18)
# 这种函数调用的时候就使用了关键字参数，这样就可以不用管参数的顺序了，
##########################
# 有了默认参数之后，调用函数的时候，这个参数可以不写，则使用默认值，
def hollo3(age,name='andy'):
    print('hello world')
    print('我今年%d岁了'%age)
    print(name,'在唱歌...')
hollo3(age=18)
#############################
# 这些参数叫做不定长参数，加了星号 * 的参数会以元组(tuple)的形式导入，加了两个星号 ** 的参数会以字典的形式导入。
def hollo3(name,*args,**kwargs):
    print('hello world')
    print(name,'在唱歌...')
    print(args)   # (60,70) # 这是返回一个元组
    print(kwargs)  # {'a': 1, 'b': 2} 这是一个字典，
hollo3('andy',60,70,a=1,b=2)  # 注意这种调用的时候，
############################
sum1=lambda a,b:a+b
print(sum1(1,2))

 

###############    面向对象-类    ###############

# 面向对象：
# 一个类有三要素：类名，属性，方法，类名使用大驼峰命名法，
# 类定义：定义的时候，类名后面不需要有括号
class Person:
    # 属性：
    name='andy'
    age=18

    # 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。self代表类的实例，而非类
    def dance(self):
        print('danceing')


# 实例化类，实例化之后就是一个类对象了，实例化的时候一定类名后面要有括号
person1 = Person()
# 类对象支持两种操作：访问类的属性和方法
print(person1.age)
person1.dance()

###############    面向对象-构造方法！    ###############

# 类的初始化方法（构造方法）
# 类在实例化的时候，会自动执行以下操作：
# 1，为对象在内存中分配空间--创建对象
# 2，为对象的属性设置初始值--初始化方法
# 这是初始化方法就是 __init__方法，这是对象的内置方法
# 初始化方法是专门来定义一个类具有哪些属性的方法！！！
# 怎么在初始化方法内部定义属性？
class Person:
    # 在初始化方法中定义属性
    def __init__(self,name):
        # 语法：self.属性名=属性的初始值
        # self.name="tom" # 这种就把这个属性固定死了，不好，但是在类中，我们不希望属性固定
        # 我们可以给函数增加一个形参，用形参来替换被固定死的值，
        self.name=name # 这样你就懂了，为什么要这么写了，这是一个形参替换属性值的过程，调用的时候需要传入这个形参，这样就更加灵活了，


    def eat(self):
        print('%s爱吃美食'%self.name)


# person1=Person()
person1=Person('andy')
print(person1.name)
person1.eat()

 

###############    面向对象-私有属性和私有方法    ###############

# 私有属性和私有方法，
# 只能在类的内部访问，外部不能访问，
# 怎么定义：在定义属性或者方法的时候，在属性名或者方法名前面增加两个下划线，就是定义私有属性或者方法了，
class Women:
    def __init__(self,name):
        self.name=name
        self.__age_private=18
        self.age_public=19

    def __str__(self):
        '''对类的描述'''
        return '这是一个女人类'

    def secret_public(self):
        print('名字是%s,年龄是%d'%(self.name,self.__age_private))  # # 所以私有属性外部不能访问，，但是内部可以访问，

    def __secret_private(self):
        print('名字是%s,年龄是%d'%(self.name,self.__age_private))


xiaomei=Women('小美')
print(xiaomei.age_public)
# print(xiaomei.__age_private)
print(xiaomei._Women__age_private)  # python中没有真正意义上的私有，#在日常开发中，不要使用这种方法去访问对象的属性和方法
xiaomei.secret_public()  # 所以私有属性外部不能访问，，但是内部可以访问，
# xiaomei.__secret_private()
xiaomei._Women__secret_private()
print(xiaomei)  # 输出的就是对类的描述，不再是一个看不懂的内容了，

 

##############    面向对象-继承    ###############

# 继承
# 使用动物类和狗类
class Animal:
    def eat(self):
        print('eat')

    def drink(self):
        print('drink')

    def run(self):
        print('run')

    def sleep(self):
        print('sleep')


# 狗类继承动物父类
class Dog(Animal):
    def dark(self):
        print('wangwang......')


    # 重写父类方法有两种情况：
    # 第一种情况，覆盖父类的方法
    # 如果父类的方法不能满足子类的需要，就需要重写父类的方法
    # 怎么实现：定义一个和父类同名的方法，然后自己实现就可以了，调用的时候会调用子类的重写的方法
    def sleep(self):
        print('这个狗狗睡觉比较久')

    # 第二种情况：对父类方法进行扩展
    # 就是子类方法包含了父类方法的实现，这是在父类的基础上，增加功能，
    # 怎么实现：
    def eat(self):  # 仍然需要重写父类的方法，
        # 1,针对子类特有的的需求，编写代码
        # 2,使用super调用原本父类中封装的方法
        # 3,增加其他子类的代码
        super().eat()  # 这一步就是把父类的代码继承过来了，
        print('狗狗有时候吃的好多')  # 这一步就是子类新增的功能，



taidi=Dog()
taidi.sleep()
taidi.dark()
taidi.eat()

 

##############    匿名函数    ###############

 

 

 

 

##############    匿名函数    ###############

 

 

##############    匿名函数    ###############

 

 

 

##############    匿名函数    ###############

 

 

###############    结束线   ###############