শর্তসাপেক্ষ বিন্যাসন

শর্তসাপেক্ষ বিন্যাস আপনাকে কক্ষগুলিকে বিন্যাস করতে দেয় যাতে তাদের উপস্থিতি তাদের ধারণকৃত মান অনুসারে বা অন্যান্য কক্ষের মান অনুসারে গতিশীলভাবে পরিবর্তিত হয়। শর্তসাপেক্ষ বিন্যাসের অনেক সম্ভাব্য অ্যাপ্লিকেশন রয়েছে, এই ব্যবহারগুলি সহ:

  • একটি নির্দিষ্ট থ্রেশহোল্ডের উপরে সেল হাইলাইট করুন (উদাহরণস্বরূপ, $2,000-এর বেশি লেনদেনের জন্য বোল্ড টেক্সট ব্যবহার করে)।
  • কক্ষগুলিকে বিন্যাস করুন যাতে তাদের রঙ তাদের মানের সাথে পরিবর্তিত হয় (উদাহরণস্বরূপ, $2,000-এর বেশি পরিমাণ বাড়লে আরও তীব্র লাল পটভূমি প্রয়োগ করা)।
  • অন্যান্য ঘরের বিষয়বস্তুর উপর ভিত্তি করে কক্ষগুলিকে গতিশীলভাবে বিন্যাস করুন (উদাহরণস্বরূপ, বৈশিষ্ট্যগুলির ঠিকানা হাইলাইট করা যার "বাজারে সময়" ক্ষেত্র > 90 দিন)।

এমনকি আপনি কোষগুলিকে তাদের মান এবং অন্যান্য কক্ষগুলির উপর ভিত্তি করে বিন্যাস করতে পারেন৷ উদাহরণস্বরূপ, আপনি পরিসরের মধ্যম মানের তুলনায় তাদের মানের উপর ভিত্তি করে একটি পরিসর বিন্যাস করতে পারেন:

গড় বয়সের উপরে বা নীচে মানগুলি হাইলাইট করার জন্য ফর্ম্যাটিং৷

চিত্র 1. গড় বয়সের উপরে বা নীচে মানগুলি হাইলাইট করতে ফর্ম্যাটিং৷

এই উদাহরণে, প্রতিটি সারির কক্ষগুলি তাদের age কলামের মানটি সমস্ত বয়সের মধ্যকার মানের সাথে কীভাবে তুলনা করে সেই অনুযায়ী বিন্যাস করা হয়েছে৷ যে সারিগুলির বয়স মাঝারিটির উপরে তাদের লাল টেক্সট রয়েছে এবং মধ্যমের নীচে একটি লাল পটভূমি রয়েছে৷ সারির দুটিতে age জন্য একটি মান রয়েছে যা গড় বয়সের (48) সাথে মেলে এবং এই কক্ষগুলি কোনো বিশেষ বিন্যাস পায় না। (উৎস কোডের জন্য যা এই শর্তসাপেক্ষ বিন্যাস তৈরি করে, নীচের উদাহরণটি দেখুন।)

শর্তাধীন বিন্যাস নিয়ম

শর্তসাপেক্ষ বিন্যাস বিন্যাস নিয়ম ব্যবহার করে প্রকাশ করা হয়। প্রতিটি স্প্রেডশীট এই নিয়মগুলির একটি তালিকা সঞ্চয় করে, এবং সেগুলি তালিকায় প্রদর্শিত একই ক্রমে প্রয়োগ করে৷ Google Sheets API আপনাকে এই ফর্ম্যাটিং নিয়মগুলি যোগ করতে, আপডেট করতে এবং মুছতে দেয়৷

প্রতিটি নিয়ম একটি লক্ষ্য পরিসীমা, নিয়মের ধরন, নিয়মটি ট্রিগার করার শর্তাবলী এবং প্রয়োগ করার জন্য যেকোনো বিন্যাস উল্লেখ করে।

লক্ষ্য পরিসর — এটি একটি একক কক্ষ, কক্ষের একটি পরিসর বা একাধিক পরিসর হতে পারে।

নিয়মের ধরন - নিয়মের দুটি বিভাগ আছে:

যে শর্তগুলি মূল্যায়ন করা হয়েছে, এবং আপনি যে ফর্ম্যাটগুলি প্রয়োগ করতে পারেন, সেগুলি এই নিয়মের প্রতিটি প্রকারের জন্য আলাদা, নিম্নলিখিত বিভাগগুলিতে বিশদ বিবরণ দেওয়া হয়েছে৷

বুলিয়ান নিয়ম

একটি BooleanRule সংজ্ঞায়িত করে যে একটি নির্দিষ্ট বিন্যাস প্রয়োগ করতে হবে কিনা, একটি BooleanCondition উপর ভিত্তি করে যা true বা false মূল্যায়ন করে। একটি বুলিয়ান নিয়ম ফর্ম নেয়:

{
  "condition": {
    object(BooleanCondition)
  },
  "format": {
    object(CellFormat)
  },
}

শর্তটি বিল্ট-ইন ConditionType ব্যবহার করতে পারে, অথবা এটি আরও জটিল মূল্যায়নের জন্য একটি কাস্টম সূত্র ব্যবহার করতে পারে।

অন্তর্নির্মিত প্রকারগুলি আপনাকে সাংখ্যিক থ্রেশহোল্ড, পাঠ্য তুলনা, বা একটি কক্ষ জনবহুল কিনা সে অনুযায়ী বিন্যাস প্রয়োগ করতে দেয়। উদাহরণস্বরূপ, NUMBER_GREATER মানে কক্ষের মান অবশ্যই শর্তের মানের থেকে বেশি হতে হবে। নিয়ম সবসময় টার্গেট সেল বিরুদ্ধে মূল্যায়ন করা হয়.

কাস্টম সূত্র হল একটি বিশেষ শর্তের ধরন যা আপনাকে একটি নির্বিচারে অভিব্যক্তি অনুসারে বিন্যাস প্রয়োগ করতে দেয়, যা শুধুমাত্র লক্ষ্য কক্ষের নয়, যেকোনো ঘরের মূল্যায়নের অনুমতি দেয়। শর্তের সূত্রটিকে true মূল্যায়ন করতে হবে।

একটি বুলিয়ান নিয়ম দ্বারা প্রয়োগ করা বিন্যাস সংজ্ঞায়িত করতে, আপনি সংজ্ঞায়িত করতে CellFormat প্রকারের একটি উপসেট ব্যবহার করেন:

  • কক্ষের পাঠ্যটি বোল্ড, তির্যক বা স্ট্রাইকথ্রু কিনা।
  • ঘরে পাঠ্যের রঙ।
  • ঘরের পটভূমির রঙ।

গ্রেডিয়েন্ট নিয়ম

একটি GradientRule রঙের একটি পরিসীমা সংজ্ঞায়িত করে যা মানগুলির একটি পরিসরের সাথে মিলে যায়। একটি গ্রেডিয়েন্ট নিয়ম ফর্ম নেয়:

{
  "minpoint": {
    object(InterpolationPoint)
  },
  "midpoint": {
    object(InterpolationPoint)
  },
  "maxpoint": {
    object(InterpolationPoint)
  },
}

প্রতিটি InterpolationPoint একটি রঙ এবং এর সংশ্লিষ্ট মান নির্ধারণ করে। তিনটি পয়েন্টের একটি সেট একটি রঙের গ্রেডিয়েন্টকে সংজ্ঞায়িত করে।

শর্তসাপেক্ষ বিন্যাস নিয়ম পরিচালনা করুন

শর্তসাপেক্ষ ফর্ম্যাটিং নিয়মগুলি তৈরি করতে, সংশোধন করতে বা মুছতে, উপযুক্ত অনুরোধের ধরন সহ spreadsheets.batchUpdate পদ্ধতি ব্যবহার করুন:

  • AddConditionalFormatRuleRequest ব্যবহার করে প্রদত্ত সূচকে তালিকায় নিয়ম যোগ করুন।

  • UpdateConditionalFormatRuleRequest ব্যবহার করে প্রদত্ত সূচীতে তালিকার নিয়মগুলি প্রতিস্থাপন বা পুনর্বিন্যাস করুন।

  • DeleteConditionalFormatRuleRequest ব্যবহার করে প্রদত্ত সূচকে তালিকা থেকে নিয়মগুলি সরান।

উদাহরণ

নিম্নলিখিত উদাহরণটি এই পৃষ্ঠার শীর্ষে স্ক্রিনশটে দেখানো শর্তসাপেক্ষ বিন্যাস কীভাবে তৈরি করতে হয় তা দেখায়। অতিরিক্ত উদাহরণের জন্য, শর্তসাপেক্ষ বিন্যাস নমুনা পৃষ্ঠা দেখুন।

অ্যাপস স্ক্রিপ্ট

sheets/api/spreadsheet_snippets.gs
/**
 * conditional formatting
 * @param {string} spreadsheetId spreadsheet ID
 * @returns {*} spreadsheet
 */
Snippets.prototype.conditionalFormatting = (spreadsheetId) => {
  try {
    let myRange = Sheets.newGridRange();
    myRange.sheetId = 0;
    myRange.startRowIndex = 0;
    myRange.endRowIndex = 11;
    myRange.startColumnIndex = 0;
    myRange.endColumnIndex = 4;

    // Request 1
    let rule1ConditionalValue = Sheets.newConditionValue();
    rule1ConditionalValue.userEnteredValue = '=GT($D2,median($D$2:$D$11))';

    let rule1ConditionFormat = Sheets.newCellFormat();
    rule1ConditionFormat.textFormat = Sheets.newTextFormat();
    rule1ConditionFormat.textFormat.foregroundColor = Sheets.newColor();
    rule1ConditionFormat.textFormat.foregroundColor.red = 0.8;

    let rule1Condition = Sheets.newBooleanCondition();
    rule1Condition.type = 'CUSTOM_FORMULA';
    rule1Condition.values = [rule1ConditionalValue];

    let rule1BooleanRule = Sheets.newBooleanRule();
    rule1BooleanRule.condition = rule1Condition;
    rule1BooleanRule.format = rule1ConditionFormat;

    let rule1 = Sheets.newConditionalFormatRule();
    rule1.ranges = [myRange];
    rule1.booleanRule = rule1BooleanRule;

    let request1 = Sheets.newRequest();
    let addConditionalFormatRuleRequest1 =
      Sheets.newAddConditionalFormatRuleRequest();
    addConditionalFormatRuleRequest1.rule = rule1;
    addConditionalFormatRuleRequest1.index = 0;
    request1.addConditionalFormatRule = addConditionalFormatRuleRequest1;

    // Request 2
    let rule2ConditionalValue = Sheets.newConditionValue();
    rule2ConditionalValue.userEnteredValue = '=LT($D2,median($D$2:$D$11))';

    let rule2ConditionFormat = Sheets.newCellFormat();
    rule2ConditionFormat.textFormat = Sheets.newTextFormat();
    rule2ConditionFormat.textFormat.foregroundColor = Sheets.newColor();
    rule2ConditionFormat.textFormat.foregroundColor.red = 1;
    rule2ConditionFormat.textFormat.foregroundColor.green = 0.4;
    rule2ConditionFormat.textFormat.foregroundColor.blue = 0.4;

    let rule2Condition = Sheets.newBooleanCondition();
    rule2Condition.type = 'CUSTOM_FORMULA';
    rule2Condition.values = [rule2ConditionalValue];

    let rule2BooleanRule = Sheets.newBooleanRule();
    rule2BooleanRule.condition = rule2Condition;
    rule2BooleanRule.format = rule2ConditionFormat;

    let rule2 = Sheets.newConditionalFormatRule();
    rule2.ranges = [myRange];
    rule2.booleanRule = rule2BooleanRule;

    let request2 = Sheets.newRequest();
    let addConditionalFormatRuleRequest2 =
      Sheets.newAddConditionalFormatRuleRequest();
    addConditionalFormatRuleRequest2.rule = rule2;
    addConditionalFormatRuleRequest2.index = 0;
    request2.addConditionalFormatRule = addConditionalFormatRuleRequest2;

    // Batch send the requests
    const requests = [request1, request2];
    let batchUpdate = Sheets.newBatchUpdateSpreadsheetRequest();
    batchUpdate.requests = requests;
    const response =
      Sheets.Spreadsheets.batchUpdate(batchUpdate, spreadsheetId);
    return response;
  } catch (err) {
    // TODO (developer) - Handle exception
    console.log('Failed with error %s', err.message);
  }
};

জাভা

sheets/snippets/src/main/java/ConditionalFormatting.java
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.sheets.v4.Sheets;
import com.google.api.services.sheets.v4.SheetsScopes;
import com.google.api.services.sheets.v4.model.AddConditionalFormatRuleRequest;
import com.google.api.services.sheets.v4.model.BatchUpdateSpreadsheetRequest;
import com.google.api.services.sheets.v4.model.BatchUpdateSpreadsheetResponse;
import com.google.api.services.sheets.v4.model.BooleanCondition;
import com.google.api.services.sheets.v4.model.BooleanRule;
import com.google.api.services.sheets.v4.model.CellFormat;
import com.google.api.services.sheets.v4.model.Color;
import com.google.api.services.sheets.v4.model.ConditionValue;
import com.google.api.services.sheets.v4.model.ConditionalFormatRule;
import com.google.api.services.sheets.v4.model.GridRange;
import com.google.api.services.sheets.v4.model.Request;
import com.google.api.services.sheets.v4.model.TextFormat;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/* Class to demonstrate the use of Spreadsheet Conditional Formatting API */
public class ConditionalFormatting {
  /**
   * Create conditional formatting.
   *
   * @param spreadsheetId - Id of the spreadsheet.
   * @return updated changes count.
   * @throws IOException - if credentials file not found.
   */
  public static BatchUpdateSpreadsheetResponse conditionalFormat(String spreadsheetId)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Collections.singleton(SheetsScopes.SPREADSHEETS));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Create the sheets API client
    Sheets service = new Sheets.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Sheets samples")
        .build();

    List<GridRange> ranges = Collections.singletonList(new GridRange()
        .setSheetId(0)
        .setStartRowIndex(1)
        .setEndRowIndex(11)
        .setStartColumnIndex(0)
        .setEndColumnIndex(4)
    );
    List<Request> requests = Arrays.asList(
        new Request().setAddConditionalFormatRule(new AddConditionalFormatRuleRequest()
            .setRule(new ConditionalFormatRule()
                .setRanges(ranges)
                .setBooleanRule(new BooleanRule()
                    .setCondition(new BooleanCondition()
                        .setType("CUSTOM_FORMULA")
                        .setValues(Collections.singletonList(
                            new ConditionValue().setUserEnteredValue(
                                "=GT($D2,median($D$2:$D$11))")
                        ))
                    )
                    .setFormat(new CellFormat().setTextFormat(
                        new TextFormat().setForegroundColor(
                            new Color().setRed(0.8f))
                    ))
                )
            )
            .setIndex(0)
        ),
        new Request().setAddConditionalFormatRule(new AddConditionalFormatRuleRequest()
            .setRule(new ConditionalFormatRule()
                .setRanges(ranges)
                .setBooleanRule(new BooleanRule()
                    .setCondition(new BooleanCondition()
                        .setType("CUSTOM_FORMULA")
                        .setValues(Collections.singletonList(
                            new ConditionValue().setUserEnteredValue(
                                "=LT($D2,median($D$2:$D$11))")
                        ))
                    )
                    .setFormat(new CellFormat().setBackgroundColor(
                        new Color().setRed(1f).setGreen(0.4f).setBlue(0.4f)
                    ))
                )
            )
            .setIndex(0)
        )
    );

    BatchUpdateSpreadsheetResponse result = null;
    try {
      // Execute the requests.
      BatchUpdateSpreadsheetRequest body =
          new BatchUpdateSpreadsheetRequest()
              .setRequests(requests);
      result = service.spreadsheets()
          .batchUpdate(spreadsheetId, body)
          .execute();
      System.out.printf("%d cells updated.", result.getReplies().size());
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      GoogleJsonError error = e.getDetails();
      if (error.getCode() == 404) {
        System.out.printf("Spreadsheet not found with id '%s'.\n", spreadsheetId);
      } else {
        throw e;
      }
    }
    return result;
  }
}

জাভাস্ক্রিপ্ট

sheets/snippets/sheets_conditional_formatting.js
function conditionalFormatting(spreadsheetId, callback) {
  const myRange = {
    sheetId: 0,
    startRowIndex: 1,
    endRowIndex: 11,
    startColumnIndex: 0,
    endColumnIndex: 4,
  };
  const requests = [{
    addConditionalFormatRule: {
      rule: {
        ranges: [myRange],
        booleanRule: {
          condition: {
            type: 'CUSTOM_FORMULA',
            values: [{userEnteredValue: '=GT($D2,median($D$2:$D$11))'}],
          },
          format: {
            textFormat: {foregroundColor: {red: 0.8}},
          },
        },
      },
      index: 0,
    },
  }, {
    addConditionalFormatRule: {
      rule: {
        ranges: [myRange],
        booleanRule: {
          condition: {
            type: 'CUSTOM_FORMULA',
            values: [{userEnteredValue: '=LT($D2,median($D$2:$D$11))'}],
          },
          format: {
            backgroundColor: {red: 1, green: 0.4, blue: 0.4},
          },
        },
      },
      index: 0,
    },
  }];

  const body = {
    requests,
  };
  try {
    gapi.client.sheets.spreadsheets.batchUpdate({
      spreadsheetId: spreadsheetId,
      resource: body,
    }).then((response) => {
      const result = response.result;
      console.log(`${result.replies.length} cells updated.`);
      if (callback) callback(response);
    });
  } catch (err) {
    document.getElementById('content').innerText = err.message;
    return;
  }
}

Node.js

sheets/snippets/sheets_conditional_formatting.js
/**
 * Conditionally formats a Spreadsheet.
 * @param {string} spreadsheetId A Spreadsheet ID.
 * @return {obj} spreadsheet information
 */
async function conditionalFormatting(spreadsheetId) {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/spreadsheets',
  });

  const service = google.sheets({version: 'v4', auth});
  const myRange = {
    sheetId: 0,
    startRowIndex: 1,
    endRowIndex: 11,
    startColumnIndex: 0,
    endColumnIndex: 4,
  };
  const requests = [
    {
      addConditionalFormatRule: {
        rule: {
          ranges: [myRange],
          booleanRule: {
            condition: {
              type: 'CUSTOM_FORMULA',
              values: [{userEnteredValue: '=GT($D2,median($D$2:$D$11))'}],
            },
            format: {
              textFormat: {foregroundColor: {red: 0.8}},
            },
          },
        },
        index: 0,
      },
    },
    {
      addConditionalFormatRule: {
        rule: {
          ranges: [myRange],
          booleanRule: {
            condition: {
              type: 'CUSTOM_FORMULA',
              values: [{userEnteredValue: '=LT($D2,median($D$2:$D$11))'}],
            },
            format: {
              backgroundColor: {red: 1, green: 0.4, blue: 0.4},
            },
          },
        },
        index: 0,
      },
    },
  ];
  const resource = {
    requests,
  };
  try {
    const response = await service.spreadsheets.batchUpdate({
      spreadsheetId,
      resource,
    });
    console.log(`${response.data.replies.length} cells updated.`);
    return response;
  } catch (err) {
    // TODO (developer) - Handle exception
    throw err;
  }
}

পিএইচপি

sheets/snippets/src/SpreadsheetConditionalFormatting.php
use Google\Client;
use Google\Service\Drive;
use Google\Service\Sheets\BatchUpdateSpreadsheetRequest;
use Google\Service\Sheets\Request;

function conditionalFormatting($spreadsheetId)
    {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
        $client = new Google\Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Google\Service\Drive::DRIVE);
        $service = new Google_Service_Sheets($client);

        try{
            $myRange = [
                'sheetId' => 0,
                'startRowIndex' => 1,
                'endRowIndex' => 11,
                'startColumnIndex' => 0,
                'endColumnIndex' => 4,
            ];
            //execute the request
            $requests = [
                new Google_Service_Sheets_Request([
                'addConditionalFormatRule' => [
                    'rule' => [
                        'ranges' => [ $myRange ],
                        'booleanRule' => [
                            'condition' => [
                                'type' => 'CUSTOM_FORMULA',
                                'values' => [ [ 'userEnteredValue' => '=GT($D2,median($D$2:$D$11))' ] ]
                            ],
                            'format' => [
                                'textFormat' => [ 'foregroundColor' => [ 'red' => 0.8 ] ]
                                ]
                                ]
                            ],
                            'index' => 0
                            ]
                        ]),
                        new Google_Service_Sheets_Request([
                'addConditionalFormatRule' => [
                    'rule' => [
                        'ranges' => [ $myRange ],
                        'booleanRule' => [
                            'condition' => [
                                'type' => 'CUSTOM_FORMULA',
                                'values' => [ [ 'userEnteredValue' => '=LT($D2,median($D$2:$D$11))' ] ]
                            ],
                            'format' => [
                                'backgroundColor' => [ 'red' => 1, 'green' => 0.4, 'blue' => 0.4 ]
                            ]
                            ]
                        ],
                    'index' => 0
                ]
                ])
        ];

        $batchUpdateRequest = new Google_Service_Sheets_BatchUpdateSpreadsheetRequest([
            'requests' => $requests
        ]);
        $response = $service->spreadsheets->batchUpdate($spreadsheetId, $batchUpdateRequest);
        printf("%d cells updated.", count($response->getReplies()));
        return $response;
    }
    catch(Exception $e) {
        // TODO(developer) - handle error appropriately
        echo 'Message: ' .$e->getMessage();
    }
}

পাইথন

sheets/snippets/sheets_conditional_formatting.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def conditional_formatting(spreadsheet_id):
  """
  Creates the batch_update the user has access to.
  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()
  # pylint: disable=maybe-no-member
  try:
    service = build("sheets", "v4", credentials=creds)

    my_range = {
        "sheetId": 0,
        "startRowIndex": 1,
        "endRowIndex": 11,
        "startColumnIndex": 0,
        "endColumnIndex": 4,
    }
    requests = [
        {
            "addConditionalFormatRule": {
                "rule": {
                    "ranges": [my_range],
                    "booleanRule": {
                        "condition": {
                            "type": "CUSTOM_FORMULA",
                            "values": [
                                {
                                    "userEnteredValue": (
                                        "=GT($D2,median($D$2:$D$11))"
                                    )
                                }
                            ],
                        },
                        "format": {
                            "textFormat": {"foregroundColor": {"red": 0.8}}
                        },
                    },
                },
                "index": 0,
            }
        },
        {
            "addConditionalFormatRule": {
                "rule": {
                    "ranges": [my_range],
                    "booleanRule": {
                        "condition": {
                            "type": "CUSTOM_FORMULA",
                            "values": [
                                {
                                    "userEnteredValue": (
                                        "=LT($D2,median($D$2:$D$11))"
                                    )
                                }
                            ],
                        },
                        "format": {
                            "backgroundColor": {
                                "red": 1,
                                "green": 0.4,
                                "blue": 0.4,
                            }
                        },
                    },
                },
                "index": 0,
            }
        },
    ]
    body = {"requests": requests}
    response = (
        service.spreadsheets()
        .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
        .execute()
    )
    print(f"{(len(response.get('replies')))} cells updated.")
    return response

  except HttpError as error:
    print(f"An error occurred: {error}")
    return error


if __name__ == "__main__":
  # Pass: spreadsheet_id
  conditional_formatting("1CM29gwKIzeXsAppeNwrc8lbYaVMmUclprLuLYuHog4k")

রুবি

sheets/snippets/lib/spreadsheet_snippets.rb
my_range = {
  sheet_id:           0,
  start_row_index:    1,
  end_row_index:      11,
  start_column_index: 0,
  end_column_index:   4
}
requests = [{
  add_conditional_format_rule: {
    rule:  {
      ranges:       [my_range],
      boolean_rule: {
        condition: {
          type:   'CUSTOM_FORMULA',
          values: [{ user_entered_value: '=GT($D2,median($D$2:$D$11))' }]
        },
        format:    {
          text_format: { foreground_color: { red: 0.8 } }
        }
      }
    },
    index: 0
  }
}, {
  add_conditional_format_rule: {
    rule:  {
      ranges:       [my_range],
      boolean_rule: {
        condition: {
          type:   'CUSTOM_FORMULA',
          values: [{ user_entered_value: '=LT($D2,median($D$2:$D$11))' }]
        },
        format:    {
          background_color: { red: 1, green: 0.4, blue: 0.4 }
        }
      }
    },
    index: 0
  }
}]
body = {
  requests: requests
}
batch_update = Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest.new
batch_update.requests = requests
result = service.batch_update_spreadsheet(spreadsheet_id, batch_update)
puts "#{result.replies.length} cells updated."