因为需求, 需要用到py, 所以来学学py, 因为有java基础 一小时入门py语法是不成问题的, 但是仅仅入门基础语法而已, 不涉及算法,不涉及大数据,机器学习,人工智能, 但是py这么火爆,就在于这几个分支遍地开花,后续的路还好长啊

py的语法是真的简单, 跟java比,真的简单太多了, 而且他的代码很有条理, 因为他是严格控制缩进的,在一个缩进块中,就好比一个隐形的大括号一样,限制着变量的声明周期

  • 标识符: 程序员定义的变量名,函数名

    • 可以由字母数字下划线组成
    • 不能用数字开头
    • 不能和已经存在的关键字重名
  • 关键字: Python内置的标识符
  • 文件名: 不推荐文件名以数字开头,否则不能通过import关键字导入其他文件使用
  • 单行注释使用 #
  • 多行注释使用 ”’ XXX ”’

加减乘除的使用方法和其他语言完全相同

取整数 求商

  1. 9//2=4
  1. 2**3=8
  1. print([1,2]+[3,4])#[1, 2, 3, 4]
  1. print([1,2]*2)#[1, 2, 1, 2]
  1. print(3 in [1,2,3])#True
  2. print(3 not in [1,2,3])#False
  1. def test(list):
  2.     list+=list
  3.     print(list)#[1, 3, 4, 1, 3, 4]
  4. gl_list=[1,3,4]
  5. test(gl_list)
  6. print(gl_list)#[1, 3, 4, 1, 3, 4]

不可变 全局变量在函数内部 使用 = ,这种赋值操作, 原全局变量不会被影响

  1. gl_num=1
  2. def test(num):
  3.     print(num)#1
  4.     num=2
  5.     print(num)#2
  6.     num+=3
  7.     print(num)#5
  8. test(gl_num)
  9. print(gl_num)#1

在函数中, 如果全局变量是可变类型的, 如果在函数中往这个全局变量中添加内容了, 全局变量的值会受到影响

  1. gl_num=[1,3,4]
  2. def test(num):
  3.     print(num)#[1, 3, 4]
  4.     num+=[1]
  5.     print(num)#[1, 3, 4, 1]
  6. test(gl_num)
  7. print(gl_num)#[1, 3, 4, 1]
  1. =
  2. +=
  3. -=
  4. *=
  5. /=      除法赋值运算符
  6. //=     取整赋值运算符
  7. %=      取模赋值运算符
  8. **=     幂赋值运算符
  1. \t 在控制台上输出一个制表符
  2. \n 在控制台上输出一个换行符
  3. \\ 反斜杠符
  4. \' 输出单引号
  5. \r 回车
  • 区分大小写 Abc != abc
  • 为了保证代码的质量, = 两边预留两个空格
  • 所有单词全是小写字节
  • 单词之间使用下划线连接 first_name

在py中,变量的类型是有不需要程序员指定,因为它是在运行时,由解释器自己推断出来的

例:

  1. name="小明"    # str  字符串类型
  2. age=18         # int 整形
  3. sex= True      # bool 布尔类型  True False 首字母都是大写
  4. height=1.78    # float 单精度小数类型
  5. weiht=75.0     # float
  6. weiht2=75      # int
  • 数字型
    • int: 整形
    • float: 浮点型
    • bool:布尔型
      • True: 所有非0的数字
      • False:0
    • 复数类型: complex
      • 主要用于科学计算
  • 非数字型:
    • str:字符串
    • 列表
    • 元组
    • 字典
      “`py
      在py2.0中
      type(2 ** 32) –> int
      type(2 ** 64) –> long
  1. print(type(2 ** 32))
  2. print(type(2 ** 64))
  3. print(type(2 ** 128))
  4. print(type(2 ** 256))
  5. print(type(2 ** 512))
  6. print(type(2 ** 1024))

type函数可以直接查看变量的类型

  1. print(type(name))  # 结果 <class 'str'>
  • 相同类型之间的计算规则
    • 数值型变量之间的计算
    • bool型, True被转换成1 False被转换成0
    • 字符串之间使用 + 拼接成连续串
  • 不同类型数据之间的计算规则
    • 字符串 * 整数 实现重复拼接串
  1. print("$"*10)#$$$$$$$$$$
  • 数字型变量和字符串之间不能进行其他类型操作
  1. d=10
  2. f="10.5"
  3. g=True
  4. print(d+f+g)#TypeError: unsupported operand type(s) for +: 'int' and 'str'
  • 变量的输入输出
  1. passwd = input("请输入密码")
  2. print(passwd)
  3. print(type(passwd))
  • 类型转换
  1. 类型转换函数
  2. int(X)#将输入转换成整数
  3. float(X)#将输入转换成浮点型
  • 变量的格式化输出
  1. %s: 字符串
  2. %d: 有符号十进制整数  %06d 表示输出的整形显示的位数, 不足的地方使用0补全
  3. %f: 浮点型  %.02f 表示显示小数点后两位
  4. %%: 输出%
  6. q=999
  7. print("格式化的字符串是  %06d "%q)#000999
  8. w=123.123456
  9. e=123.123456
  10. r=123.123456
  11. print("格式化的字符串%.2f"%w)#123.12
  12. print("%.1f %.2f %.3f"% (w,e,r))#123.1 123.12 123.123
  13. t=0.25
  14. print("%.2f%%" % t)#0.25%
  • 全局变量

全局变量推荐定义在全部代码的最上方

全局变量的推荐命名规则

  1. g_XXX   gl_XXX

如何在 函数内部修改全局变量?

先使用 global 进行修饰,再修改

如: 列表 元组 字典 字符串 公共方法

在python中全部的非数字型变量都支持以下特点

  1. 都是一个序列, 也可以理解成容器
  2. 取值 []
  3. 遍历 for in
  4. 计算长度,最大/小 值 比较 删除
  5. 连接+ 重复*
  6. 切片

列表,在java叫数组

虽然列表可以存储不同类型的数据,但是绝大多数情况下, 用它存储相同类型的数据

使用 [] 定义, 数据之间使用 , 分隔
列表的索引从 0 开始

py中提供的常用操作

  1. python 中对列表提供的操作
  2. 1. 增加   列表insert(索引,数据)      在指定位置插入数据
  3.           列表append(数据)           在末尾追加数据
  4.           列表extend(列表2)         将列表2的数据追加到列表
  5. 2. 修改   列表[索引]=新值            修改指定索引的数据
  6. 3. 删除   del列表[索引]              删除指定索引的数据
  7.           列表.remove[数据]         删除第一个出现的指定的数据
  8.           列表.pop                  删除末尾的数据
  9.           列表.pop(索引)            删除指定索引的数据
  10.           列表.clear                清空列表
  11. 4. 统计   len(列表)                 列表长度
  12.           列表.count(数据)          数据在列表中出现的次数
  13. 5. 排序   列表.sort()               升序
  14.           列表.sort(reserve=true)   降序排序
  15.           列表.reserve()            逆序,反转
  16. 6. 取索引  列表.index(数据)          返回数据在列表中的索引
  • 把变量从内存中删除掉
  1. del name_list[0]
  2. print(name_list[0])
  • 第一个参数位置的self 直接忽略就行
  • 迭代
  1. for name in name_list:
  2.     print(name)

元组 Tuple 和列表类似,但是元组的元素 不能修改

通常使用 元组 存储不同类型的数据

元组表示多个元素组成的序列

下标从0开始
用户存储一串信息, 数据之间使用 逗号 分隔

  • 定义元组
  1. info_tuple = ("zhangsan",18,1.75)
  2. print(type(info_tuple)) # <class 'tuple'>
  • 取值
  1. print(info_tuple[0])
  2. print(info_tuple[1])
  3. print(info_tuple[2])
  4. # print(info_tuple[3])#tuple index out of range
  • 取索引
  1. print(info_tuple.index("zhangsan")) # 0
  • 统计计数
  1. print(info_tuple.count("zhangsan")) # 1
  • 定义空元组,一般是不定义空元组的,但是没意义,因为不能再修改
  1. empty_tuple = ()
  2. print(type(empty_tuple))#<class 'tuple'>
  • 定义一个元素的元组
  1. single_touble1 = (5) # 解释器会忽略两个小括号
  2. print(type(single_touble1))# <class 'int'>   被解释器解释成了int类型
  4. single_touble2 = (5,) # 多加上一个逗号
  5. print(type(single_touble2))#<class 'tuple'>
  • 元组的应用场景
    • 作为入参: 可以使得函数一次性接受多个参数
    • 让列表不可变,保护数据的安全
    • 作为返回值: 可以使函数一次性返回多个值
    • 格式化字符串, 在print函数中,格式化字符串时, 格式化字符串后面的() 本质上就是一个元组

例:

  1. print("年龄: %d   姓名:%s"%(123,"小明"))
  2. info_tuple = ("zhangsan",18,1.75)
  3. print(type(info_tuple)) # <class 'tuple'>
  4. info_str="姓名:%s  年龄: %d  身高%.2f "% info_tuple
  5. print(info_str)
  • 列表转元组
  1. my_list = [1,3,4,5]
  2. my_list = tuple(my_list)
  3. print(type(my_list)) # my_list
  • 函数返回元组
  1. def mea():
  2.     a=1
  3.     b=2
  4.     return (a,b)
  5.     
  6. # 接受
  7. result = mea()
  9. # 使用
  10. print(result[0])
  11. print(result[1])
  13. # 也可以这样接收, 注意, 变量的格式和元组的数保持一致
  14. gl_a, gl_b = mea()

字典是 无序对象 的集合 类似java中的 map,或者说是java中的一个对象

说它是无序,使用print输出时,每次的顺序不唯一

因为我们只关心通过key 取出 保存的数据,而不关心存储的顺序

字典使用{}定义

字典使用键值对存储数据, 键值对使用 逗号分隔

key 是索引,并且是 不可变类型的变量才能当key (列表,字典是可变类型,不能当成key)

value 是数据

键和值之间使用 : 冒号分隔

键是唯一的

值任意数据类型

*　定义字典

  1. person={"name":"张三","age":23}
  • 取值
  1. # 取值
  2. print(person["name"])# 入参位置的name是key
  3. # print(xiaoming["name123"])# KeyError: 'name123'   key不存在,程序会报错
  • 添加修改
  1. # 添加/修改, 如果key存在了, 就是修改, key不存在就是添加
  2. person["height"]=1.78
  3. print(person)
  • 删除
  1. person.pop("age")
  2. print(person)
  • 统计键值对的数量
  1. print(len(person))
  • 合并字典
  1. new_dir={"class":"大一"}
  2. person.update(new_dir) # 如果被合并的字典中包含原有的键值对, 会覆盖旧值
  3. print(person)
  • 清空字典xiaoming
  1. xiaoming.clear()
  2. print(xiaoming)
  • 遍历
  1. for k in person:
  2.     print(" value = %s "%person[k])
  • 字典和列表搭配使用
  1. 将多个字典存入一个列表中,然后遍历列表对实现对字典批量处理的动作
  2. list = [
  3.         {},
  4.         {},
  5.         {}
  6.         ]
  1. if 要顶格写
  3. if 条件1:
  4.     XXX
  5. elif ()or()or():
  6.     XXX
  7. else:
  8.     XXX
  10. 严格控制缩进, tab 和 空格不能混用,容易乱
  1. 与  and
  2. 或  or
  3. 非  not
  5. 条件1 and 条件2
  6. 条件1 or 条件2
  8. 对条件取反
  9. not 条件1
  10. not 条件2
  • for循环
  1. for 变量 in 集合:
  2.     XXX
  3. else:
  4.     XXX
  • while循环
  1. i=0
  2. while i<5:
  3.     print("i= %d"%i)
  4.     #i=i+1
  5.     i+=1

格式如下

  1. def 函数名():
  2.     XXX
  3.     XXX
  5. def 函数名():
  6.     XXX
  7.     XXX
  8.     return XXX
  • 随机数
  1. import random
  2. n = random.randint(1,5)# 1 <= n <= 5
  3. m = random.randint(5,5)# n = 5
  4. # s = random.randint(10,5)# 第一个数大于第二个数则保存
  5. print("age== %d "%n)
  • 缺省参数, 简化人们的编码
  1. gl_list=[5,126,7]
  2. gl_list.sort()
  3. print(gl_list) # 默认正序
  4. gl_list.sort(reverse=True) # 缺省参数位置,可以设置逆序
  5. print(gl_list)
  • 指定缺省参数的默认值
  1. def print_info(name,gender=True):
  2.     default_gender="男生"
  3.     if not gender:
  4.         default_gender = "女生"
  6.     print("%s 是 %s"%(name,default_gender))
  8. print_info("小明")
  9. print_info("小明",False)

注意事项:缺省参数必须保证它出现在 !!! 参数列表的末尾 !!!

  • 如何调用含有多个参数, 如果有多个参数的话, 中间位置的参数最好也设置上默认值
  1. def print_info(name,age="",gender=True):
  2.     default_gender="男生"
  3.     if not gender:
  4.         default_gender = "女生"
  6.     print("%s 是 %s"%(name,default_gender))
  8. print_info("小明")
  9. print_info("小明",gender=False)
  • 多值参数

在参数名前添加一个 * 可以接收元组

在参数名前添加两个 * 可以接收字典

习惯用下面的方式命名:

  • *args :存放元组
  • **kw :存放字典数据
  2. def demo(num,*nums,**person):
  3.     print(num)
  4.     print(nums)
  5.     print(person)
  7. demo(1)
  8. '''
  9. 1
  10. ()
  11. {}
  12. '''
  13. demo(1,23,4,5,6)
  15. '''
  16. 1
  17. (23, 4, 5, 6)
  18. {}
  19. '''
  21. demo(1,23,4,5,6,name="张三",age=18)
  22. '''
  23. 1
  24. (23, 4, 5, 6)
  25. {'name': '张三', 'age': 18}
  26. '''
  30. # 对比去除* 的写法, 其实用户在使用时变麻烦了,多增加了一个小括号
  31. def print_info1(name):
  32.     print(name)
  34. print_info1((1,2,3,4))#(1, 2, 3, 4)
  1. def demo(*args,**kwargs):
  2.     print(args)
  3.     print(kwargs)
  5. gl_nums=(1,2,3)
  6. gl_dir={"name":"李四","age":12}
  8. demo(gl_nums,gl_dir)
  9. '''
  10.  下面的运行结果其实是差强人意的, 需要进行拆包
  11. ((1, 2, 3), {'name': '李四', 'age': 12})
  12. {}
  13. '''
  15. # 不拆包,直接调用
  16. demo(1,2,3,name="李四",age=123)
  17. '''
  18. (1, 2, 3)
  19. {'name': '李四', 'age': 123}
  20. '''
  22. # 拆包
  23. demo(*gl_nums,**gl_dir)
  24. '''
  25. (1, 2, 3)
  26. {'name': '李四', 'age': 12}
  27. '''

版权声明：本文为ZhuChangwu原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/ZhuChangwu/p/11508505.html