Python语法基础（注释、变量、数据类型、字符串、函数、运算符）

Python基础

编码

原码

+1 = [00000001]
-1 = [10000001]

反码

正数的反码是其本身，负数的反码是在原码的基础上，符号位不变，其余个位取反

+1 = [00000001]
-1 =  [11111110]

补码

正数的补码是其本身，负数的补码是在其原码的基础上，符号位不变，其余个位取反，再加1

+1 = [00000001]
-1 = [11111111]

pip

install

pip install packagename # 安装包
pip install packagename = xx # 安装指定版本的包
pip install -r filename # 批量升级包
pip install -U pip # 升级pip
pip install --upgrade packagename # 升级指定的包

uninstall

pip uninstall packagename # 卸载指定的包
pip uninstall -r # 批量卸载包

show

pip show packagename # 查看已安装指定包版本信息

list

pip list # 查看已安装的包

注释

单行注释

python # 号后内容为注释内容
快捷键Ctrl + /

# 我是一行注释 

多行注释

python 用三个单引号或者双引号表示多行注释

'''
注释第一行
注释第二行
'''
"""
注释第一行
注释第二行
"""

变量

标识符

命名规范

Python中定义各种名字的统一规范：

• 由数字字母下划线组成
• 不能数字开头
• 不能使用内置关键字
• 严格区分大小写

命名习惯：

见名知义

• 大驼峰：每个单词首字母都大写，如MyName
• 小驼峰：第二个（含）以后的首字母大写，如myName
• 下划线：如my_name

变量

变量名自定义要满足标识符命名规范
变量就是数据内存地址的名字
变量名=值

name = "Tom"
print(name) # "Tom"

交换变量值

借助第三个变量

a = 1
b = 2
# 借助第三个变量
c = a
a = b
b = c
a # 2
b # 1

python方法

a = 1
b = 2
a,b = b,a
a # 2
b # 1

数据类型

数值

print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'> 
print(type(1 + 1j)) # <class 'complex'>

布尔型

print(type(True)) # <class 'bool'> 
print(type(False)) # <class 'bool'>

字符串

字符串是不可变类型，需要用引号，是序列可以遍历
程序中使用str unicode类型，保存文件或网络传输是用bytes类型

print(type("hello world!")) # <class 'str'> python3字符串str默认是Unicode类型
print(type("abc".encode("utf-8"))) # <class 'bytes'> unicode 转 bytes
print(type("abc".encode("utf-8").decode("utf-8"))) # <class 'str'> bytes 转 unicode

列表

[数据1，数据2，…] 列表是可变类型，是序列可以遍历

print(type([1,2,3])) # <class 'list'>

元组

（数据1，数据2，…）元组数据无法修改，是序列可以遍历

print(type((1,2,3))) # <class 'tuple'>

集合

set {} 或者set() 可变无序不重复，不可以遍历

print(type(set())) # <class 'set'>
print(type({1,2})) # <class 'set'>

frozenset 不可变无序不重复，不可以遍历

print(type(frozenset())) # <class 'frozenset'>

字典

{key:value,…} 键值对，可变，可以遍历

print(type({1:2})) # <class 'dict'>

转义字符

\ 表示转义字符

\\
print("\\") # \
\n
print("a\nb") # a换行b
\t
print("a\tb") # a	b

r""内部字符串默认不转义

print(r"a\nb") # a\nb

常用函数(方法)

input()

input(“提示文字”) 接收用户输入

password = input("请输入密码：") # 请输入密码：abc123
print(password) # 'abc123'
print(type(password)) # <class 'str'>

print()

print(“内容”) 打印输出

print("hello world") # hello world
# print() 函数默认结束符end="\n",用户可自定义
print("hello world",end="*") # hello world*>>>

格式化输出
%s
格式化输出字符，%5s表示字符串位数，不足以空格补全，超出原样输出，也可以格式化整数和浮点数

name,age,weight = "pyhacker",18,10.8
print("姓名%s" %name) # 姓名pyhacker
print("姓名%10s" %name) # 姓名  pyhacker
print("姓名%5s" %name) # 姓名pyhacker
print("姓名%s,年龄%s,体重%s" %(name,age,weight)) # 姓名pyhacker,年龄18,体重10.8

%d
格式化输出整数，%5表示整数位数，不足以空格补全，超出原样输出，%05表示以0补全

print("年龄%d" %age) # 年龄18
print("年龄%5d" %age) # 年龄   18
print("年龄%05d" %age) # 年龄00018

%f
格式化输出浮点数，.2f表示小数显示位

print("体重%f" %weight) # 体重10.800000
print("体重%.2f" %weight) # 体重10.80

f""
f"内容{表达式}" 是python3.6新增格式化方法，简单易读

print(f"姓名{name}年龄{age}体重{weight}") # 姓名pyhacker年龄18体重10.8

range()

range(start,end,step) 生成从start到end的数字，步长为step，供for循环使用
range()生成的序列不包含end数字

range(3) # range(0, 3)
list(range(3)) # [0, 1, 2]
list(range(1,6,2)) # [1, 3, 5]

enumerate()

enumerate(可遍历对象，start= 0)
start 参数用来设置遍历数据的下标起始值，默认为0
函数用于将一个可遍历的数据对象（字符串、列表、元组、集合）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中
返回结果是元组，第一个数据是下标， 第二个数据值

for i in enumerate("abc"):
    print(i,end=" ") # (0, 'a') (1, 'b') (2, 'c')
for i in enumerate(["a","b","c"]):
    print(i,end=" ") # (0, 'a') (1, 'b') (2, 'c')
for i in enumerate(("a","b","c")):
    print(i,end=" ") # (0, 'a') (1, 'b') (2, 'c')
for i in enumerate({"a","b","c"}):
    print(i,end=" ") # (0, 'a') (1, 'b') (2, 'c')

dir()

查看内置函数或方法

dir(__builtins__) 

help()

查看函数使用方法

help(type)

type()

查看数据类型

type("abc") # <class 'str'> 

isinstance()

判断数据类型

isinstance("abc",str) # True 
isinstance(1,(int,float,complex)) # True 

Iterable

判断是否可迭代

from collections import Iterable
isinstance("abc",Iterable) # True

chardet.detect()

检测编码类型，需要检测的语言必须是bytes类型

import chardet
chardet.detect("北京".encode("utf-8")) # {'encoding': 'utf-8', 'confidence': 0.7525, 'language': ''}

bool()

判断布尔值

bool("") # False
bool(1) # True

repr()

repr()将函数对象转换为供解释器读取的形式

repr("abc") # "'abc'"

eval()

eval() 用来执行一个字符串表达式，并返回表达式的值

eval("1 + 2") # 3

exec()

exec()用来动态执行存储在字符串或文件中的python语句，无返回值

exec("print('hello world')") # hello world

math

import math
# 向下取整
math.floor(1.8) # 1
# 向上取整
math.ceil(1.1) # 2
# 乘方
math.pow(2,3) # 8.0
pow(2,3) # 8
# 开方
math.sqrt(9) # 3.0
# 元组形式返回除数和余数
divmod() # (3, 1)

string

import string
string.ascii_lowercase # 'abcdefghijklmnopqrstuvwxyz'
string.ascii_uppercase # 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.ascii_letters # 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.digits # '0123456789'
string.punctuation # '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
string.whitespace # ' \t\n\r\x0b\x0c'

random

import random
random.random() # 随机生成0-1之间的小数
random.randint(1,10) # 随机生成1-10之间的整数
random.uniform(1,10) # 随机生成1-10之间的整数+小数
random.choice([1,2,3]) # 随机取1个字符
random.sample([1,2,3,4,5],2) # 随机取2个字符
random.shuffle([1,2,3,4,5]) # 随机排序

数据类型转换

# int() 转整形
int("12") # 12
type(int("12")) # <class 'int'>
# float() 转浮点型
float(5) # 5.0
type(float("5")) # <class 'float'>
# complex() 转复数
complex(1) # (1+0j)
type(complex(1)) # <class 'complex'>
# str() 转字符串
str(1) # '1'
type(str(1)) # <class 'str'>
# list() 转列表
list("abc") # ['a', 'b', 'c']
type(list("abc")) # <class 'list'>
# tuple() 转元组
tuple("abc") # ('a', 'b', 'c')
type(tuple("abc")) # <class 'tuple'>
# set() 转集合
set("abc") # {'b', 'c', 'a'}
type(set("abc")) # <class 'set'>
# frozenset() 
frozenset("abc") # frozenset({'b', 'c', 'a'})
type(frozenset("abc")) # <class 'frozenset'>
# dict() 转字典
dict() # {}
type(dict()) # <class 'dict'>

进制转换

# hex() 转16进制
hex(20) # '0x14'
# oct() 转8进制
oct(10) # '0o12'
# bin() 转二进制
bin(3) # '0b11'

ASCII码转换

# ord()字母转换成ASCII码
print(ord("A")) # 65
print(ord("a")) # 97
# chr()ASCII码转换成字母
print(chr(90)) # Z
print(chr(122)) # z

运算符

混合运算符优先级：（）高于**高于*、/、//、%高于+、-

算数运算符

1+2 # 3 加
2-1 # 1 减
2*2 # 4 乘
4/2 # 2.0 除
5//2 # 2 整除
5%2 # 1 取余
2**3 # 8 乘方
(1+2)*3 # 9 括号

赋值运算符

a=1
b=c=2
d,e=3,4
a+=1
print(a) # 2
a-=1
print(a) # 1
a*=2
print(a) # 2
a/=2
print(a) # 1.0
a//=1
print(a) # 1
a%=2 
print(a) # 1.0
b**=2
print(b) # 4
c+=1+2 
print(c) # 5 注意先算复合表达式右面的值，再做赋值运算

比较运算符

1==1 # True 等于
1!=1 # False 不等于
1>1 # False 大于
1<1 # False 小于
1>=1 # True 大于等于
1<=1 # True 小于等于

逻辑运算符

1>0 and 1<2 #True and与，都真才真
1>0 and 1>2 # False
1 and 0 # 0
1 and 2 # 2 只要1个值为0，结果为0，否则结果为最后一个非0数字
1>0 or 1>2 # True or或，都假才假
1<0 or 1>2 # False
0 or 0 # 0
1 or 2 # 1 所有值为0，结果为0，否则结果为第一个非0数字
not True # False 非

本文地址：https://blog.csdn.net/pyhacker/article/details/107083506