10°

一小时入门 Python

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

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


命名:文件/标识符/关键字

  • 标识符: 程序员定义的变量名,函数名
    • 可以由字母数字下划线组成
    • 不能用数字开头
    • 不能和已经存在的关键字重名
  • 关键字: Python内置的标识符
  • 文件名: 不推荐文件名以数字开头,否则不能通过import关键字导入其他文件使用

注释

  • 单行注释使用 #
  • 多行注释使用 ''' XXX '''

算数运算符

+ - * / == != > < >= <= %

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

//

取整数 求商

9//2=4

**
幂运算

2**3=8

列表常见运算

print([1,2]+[3,4])#[1, 2, 3, 4]
print([1,2]*2)#[1, 2, 1, 2]
print(3 in [1,2,3])#True
print(3 not in [1,2,3])#False

对全局列表使用+=操作,相当于extend函数**

def test(list):
    list+=list
    print(list)#[1, 3, 4, 1, 3, 4]
gl_list=[1,3,4]
test(gl_list)
print(gl_list)#[1, 3, 4, 1, 3, 4]

全局变量使用 = 赋值

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

gl_num=1
def test(num):
    print(num)#1
    num=2
    print(num)#2
    num+=3
    print(num)#5
test(gl_num)
print(gl_num)#1

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

gl_num=[1,3,4]
def test(num):
    print(num)#[1, 3, 4]
    num+=[1]
    print(num)#[1, 3, 4, 1]
test(gl_num)
print(gl_num)#[1, 3, 4, 1]

赋值运算符

=
+=
-=
*=
/=      除法赋值运算符
//=     取整赋值运算符
%=      取模赋值运算符
**=     幂赋值运算符

转义运算符

\t 在控制台上输出一个制表符
\n 在控制台上输出一个换行符
\\ 反斜杠符
\' 输出单引号
\r 回车

变量

变量的命名:

  • 区分大小写 Abc != abc
  • 为了保证代码的质量, = 两边预留两个空格
  • 所有单词全是小写字节
  • 单词之间使用下划线连接 first_name

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

例:

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

在py3.0中 全部都是 int, 在py中的计算能力,完爆其他语言

print(type(2 ** 32))
print(type(2 ** 64))
print(type(2 ** 128))
print(type(2 ** 256))
print(type(2 ** 512))
print(type(2 ** 1024))

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

print(type(name))  # 结果 <class 'str'>
  • 相同类型之间的计算规则
    • 数值型变量之间的计算
    • bool型, True被转换成1 False被转换成0
    • 字符串之间使用 + 拼接成连续串
  • 不同类型数据之间的计算规则
    • 字符串 * 整数 实现重复拼接串
print("$"*10)#$$$$$$$$$$

  • 数字型变量和字符串之间不能进行其他类型操作
d=10
f="10.5"
g=True
print(d+f+g)#TypeError: unsupported operand type(s) for +: 'int' and 'str'
  • 变量的输入输出
passwd = input("请输入密码")
print(passwd)
print(type(passwd))
  • 类型转换
类型转换函数
int(X)#将输入转换成整数
float(X)#将输入转换成浮点型
  • 变量的格式化输出
%s: 字符串
%d: 有符号十进制整数  %06d 表示输出的整形显示的位数, 不足的地方使用0补全
%f: 浮点型  %.02f 表示显示小数点后两位
%%: 输出%

q=999 print("格式化的字符串是 %06d "%q)#000999 w=123.123456 e=123.123456 r=123.123456 print("格式化的字符串%.2f"%w)#123.12 print("%.1f %.2f %.3f"% (w,e,r))#123.1 123.12 123.123 t=0.25 print("%.2f%%" % t)#0.25%

  • 全局变量

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

全局变量的推荐命名规则

g_XXX   gl_XXX

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

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

高级变量

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

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

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

列表

列表,在java叫数组

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

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

py中提供的常用操作

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

元组

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

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

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

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

  • 定义元组
info_tuple = ("zhangsan",18,1.75)
print(type(info_tuple)) # <class 'tuple'>
  • 取值
print(info_tuple[0])
print(info_tuple[1])
print(info_tuple[2])
# print(info_tuple[3])#tuple index out of range
  • 取索引
print(info_tuple.index("zhangsan")) # 0
  • 统计计数
print(info_tuple.count("zhangsan")) # 1
  • 定义空元组,一般是不定义空元组的,但是没意义,因为不能再修改
empty_tuple = ()
print(type(empty_tuple))#<class 'tuple'>
  • 定义一个元素的元组
single_touble1 = (5) # 解释器会忽略两个小括号
print(type(single_touble1))# <class 'int'>   被解释器解释成了int类型

single_touble2 = (5,) # 多加上一个逗号 print(type(single_touble2))#<class 'tuple'>

  • 元组的应用场景
    • 作为入参: 可以使得函数一次性接受多个参数
    • 让列表不可变,保护数据的安全
    • 作为返回值: 可以使函数一次性返回多个值
    • 格式化字符串, 在print函数中,格式化字符串时, 格式化字符串后面的() 本质上就是一个元组

例:

print("年龄: %d   姓名:%s"%(123,"小明"))
info_tuple = ("zhangsan",18,1.75)
print(type(info_tuple)) # <class 'tuple'>
info_str="姓名:%s  年龄: %d  身高%.2f "% info_tuple
print(info_str)
  • 列表转元组
my_list = [1,3,4,5]
my_list = tuple(my_list)
print(type(my_list)) # my_list
  • 函数返回元组
def mea():
    a=1
    b=2
    return (a,b)

接受

result = mea()

使用

print(result[0]) print(result[1])

也可以这样接收, 注意, 变量的格式和元组的数保持一致

gl_a, gl_b = mea()

字典

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

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

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

字典使用{}定义

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

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

value 是数据

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

键是唯一的

值任意数据类型

* 定义字典

person={"name":"张三","age":23}
  • 取值
# 取值
print(person["name"])# 入参位置的name是key
# print(xiaoming["name123"])# KeyError: 'name123'   key不存在,程序会报错
  • 添加修改
# 添加/修改, 如果key存在了, 就是修改, key不存在就是添加
person["height"]=1.78
print(person)
  • 删除
person.pop("age")
print(person)
  • 统计键值对的数量
print(len(person))
  • 合并字典
new_dir={"class":"大一"}
person.update(new_dir) # 如果被合并的字典中包含原有的键值对, 会覆盖旧值
print(person)
  • 清空字典xiaoming
xiaoming.clear()
print(xiaoming)
  • 遍历
for k in person:
    print(" value = %s "%person[k])
  • 字典和列表搭配使用
将多个字典存入一个列表中,然后遍历列表对实现对字典批量处理的动作
list = [
        {},
        {},
        {}
        ]

if分支判断语句

if 要顶格写

if 条件1: XXX elif ()or()or(): XXX else: XXX

严格控制缩进, tab 和 空格不能混用,容易乱

逻辑运算符

与  and
或  or
非  not

条件1 and 条件2 条件1 or 条件2

对条件取反 not 条件1 not 条件2

循环

  • for循环
for 变量 in 集合:
    XXX
else:
    XXX
  • while循环
i=0
while i<5:
    print("i= %d"%i)
    #i=i+1
    i+=1

函数

格式如下

def 函数名():
    XXX
    XXX

def 函数名(): XXX XXX return XXX

内置函数

  • 随机数
import random
n = random.randint(1,5)# 1 <= n <= 5
m = random.randint(5,5)# n = 5
# s = random.randint(10,5)# 第一个数大于第二个数则保存
print("age== %d "%n)

缺省参数

  • 缺省参数, 简化人们的编码
gl_list=[5,126,7]
gl_list.sort()
print(gl_list) # 默认正序
gl_list.sort(reverse=True) # 缺省参数位置,可以设置逆序
print(gl_list)
  • 指定缺省参数的默认值
def print_info(name,gender=True):
    default_gender="男生"
    if not gender:
        default_gender = "女生"
print("%s 是 %s"%(name,default_gender))

print_info("小明") print_info("小明",False)

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

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

print_info("小明") print_info("小明",gender=False)

  • 多值参数

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

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

习惯用下面的方式命名:

  • *args :存放元组
  • **kw :存放字典数据

def demo(num,*nums,**person):
    print(num)
    print(nums)
    print(person)

demo(1) ''' 1 () {} ''' demo(1,23,4,5,6)

''' 1 (23, 4, 5, 6) {} '''

demo(1,23,4,5,6,name="张三",age=18) ''' 1 (23, 4, 5, 6) {'name': '张三', 'age': 18} '''

对比去除* 的写法, 其实用户在使用时变麻烦了,多增加了一个小括号

def print_info1(name): print(name)

print_info1((1,2,3,4))#(1, 2, 3, 4)

元组和字段的拆包

def demo(*args,**kwargs):
    print(args)
    print(kwargs)

gl_nums=(1,2,3) gl_dir={"name":"李四","age":12}

demo(gl_nums,gl_dir) ''' 下面的运行结果其实是差强人意的, 需要进行拆包 ((1, 2, 3), {'name': '李四', 'age': 12}) {} '''

不拆包,直接调用

demo(1,2,3,name="李四",age=123) ''' (1, 2, 3) {'name': '李四', 'age': 123} '''

拆包

demo(*gl_nums,**gl_dir) ''' (1, 2, 3) {'name': '李四', 'age': 12} '''

本文转载自博客园,原文链接:https://www.cnblogs.com/ZhuChangwu/p/11508505.html

全部评论: 0

    我有话说: